Coverage for test/end2end/test_padatious.py: 100%

1from unittest import TestCase 

2from copy import deepcopy 

3from ovos_bus_client.message import Message 

4from ovos_bus_client.session import Session 

5from ovos_utils.log import LOG 

6 

7from ovoscope import End2EndTest, get_minicroft 

8 

9 

10class TestPadatiousIntent(TestCase): 

11 

12 def setUp(self): 

13 LOG.set_level("DEBUG") 

14 self.skill_id = "ovos-skill-hello-world.openvoiceos" 

15 self.minicroft = get_minicroft([self.skill_id]) 

16 

17 def tearDown(self): 

18 if self.minicroft: 

19 self.minicroft.stop() 

20 LOG.set_level("CRITICAL") 

21 

22 def test_padatious_match(self): 

23 session = Session("123") 

24 session.lang = "en-US" 

25 session.pipeline = ["ovos-padatious-pipeline-plugin-high"] 

26 message = Message("recognizer_loop:utterance", 

27 {"utterances": ["good morning"], "lang": session.lang}, 

28 {"session": session.serialize(), "source": "A", "destination": "B"}) 

29 

30 final_session = deepcopy(session) 

31 final_session.active_skills = [(self.skill_id, 0.0)] 

32 

33 test = End2EndTest( 

34 minicroft=self.minicroft, 

35 skill_ids=[self.skill_id], 

36 source_message=message, 

37 final_session=final_session, 

38 activation_points=[f"{self.skill_id}:Greetings.intent"], 

39 # keep_original_src=[f"{self.skill_id}.activate"], # TODO 

40 expected_messages=[ 

41 message, 

42 Message(f"{self.skill_id}.activate", 

43 data={}, 

44 context={"skill_id": self.skill_id}), 

45 Message(f"{self.skill_id}:Greetings.intent", 

46 data={"utterance": "good morning", "lang": session.lang}, 

47 context={"skill_id": self.skill_id}), 

48 Message("mycroft.skill.handler.start", 

49 data={"name": "HelloWorldSkill.handle_greetings"}, 

50 context={"skill_id": self.skill_id}), 

51 Message("speak", 

52 data={"lang": session.lang, 

53 "expect_response": False, 

54 "meta": { 

55 "dialog": "hello", 

56 "data": {}, 

57 "skill": self.skill_id 

58 }}, 

59 context={"skill_id": self.skill_id}), 

60 Message("mycroft.skill.handler.complete", 

61 data={"name": "HelloWorldSkill.handle_greetings"}, 

62 context={"skill_id": self.skill_id}), 

63 Message("ovos.utterance.handled", 

64 data={}, 

65 context={"skill_id": self.skill_id}), 

66 ] 

67 ) 

68 

69 test.execute(timeout=10) 

70 

71 def test_skill_blacklist(self): 

72 session = Session("123") 

73 session.lang = "en-US" 

74 session.pipeline = ["ovos-padatious-pipeline-plugin-high"] 

75 session.blacklisted_skills = [self.skill_id] 

76 message = Message("recognizer_loop:utterance", 

77 {"utterances": ["good morning"], "lang": session.lang}, 

78 {"session": session.serialize(), "source": "A", "destination": "B"}) 

79 

80 test = End2EndTest( 

81 minicroft=self.minicroft, 

82 skill_ids=[self.skill_id], 

83 source_message=message, 

84 final_session=session, 

85 expected_messages=[ 

86 message, 

87 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}), 

88 Message("complete_intent_failure", {}), 

89 Message("ovos.utterance.handled", {}) 

90 ] 

91 ) 

92 

93 test.execute(timeout=10) 

94 

95 def test_intent_blacklist(self): 

96 session = Session("123") 

97 session.lang = "en-US" 

98 session.pipeline = ["ovos-padatious-pipeline-plugin-high"] 

99 session.blacklisted_intents = [f"{self.skill_id}:Greetings.intent"] 

100 message = Message("recognizer_loop:utterance", 

101 {"utterances": ["good morning"], "lang": session.lang}, 

102 {"session": session.serialize(), "source": "A", "destination": "B"}) 

103 

104 test = End2EndTest( 

105 minicroft=self.minicroft, 

106 skill_ids=[self.skill_id], 

107 source_message=message, 

108 final_session=session, 

109 expected_messages=[ 

110 message, 

111 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}), 

112 Message("complete_intent_failure", {}), 

113 Message("ovos.utterance.handled", {}) 

114 ] 

115 ) 

116 

117 test.execute(timeout=10) 

118 

119 def test_adapt_no_match(self): 

120 session = Session("123") 

121 session.lang = "en-US" 

122 session.pipeline = ['ovos-adapt-pipeline-plugin-high'] 

123 message = Message("recognizer_loop:utterance", 

124 {"utterances": ["good morning"], "lang": session.lang}, 

125 {"session": session.serialize(), "source": "A", "destination": "B"}) 

126 

127 test = End2EndTest( 

128 minicroft=self.minicroft, 

129 skill_ids=[self.skill_id], 

130 source_message=message, 

131 final_session=session, 

132 expected_messages=[ 

133 message, 

134 Message("mycroft.audio.play_sound", {"uri": "snd/error.mp3"}), 

135 Message("complete_intent_failure", {}), 

136 Message("ovos.utterance.handled", {}) 

137 ] 

138 ) 

139 

140 test.execute(timeout=10)