Пример #1
0
    def test_nested_stepsfiles(self):
        """Test that stepsfiles within stepsfiles are correctly handled."""
        # phisically create the files -- mocking os.open() would be too cumbersome
        stepsfile1 = self._create_temp_file(
            extension=".steps",
            contents="item_for_text.txt	some_text_matchfile.match")

        # second step file contains a reference to the first
        stepsfile2 = self._create_temp_file(extension=".steps",
                                            contents=stepsfile1)

        stepsfile3_contents = [
            "item_for_contour.png	some_contour_matchfile.match",
            "item_for_cascade.xml	some_cascade_matchfile.match",
            # third step file contains a reference to the second
            stepsfile2
        ]

        stepsfile3 = self._create_temp_file(
            prefix=self.stepsfile_name,
            extension=".steps",
            contents=os.linesep.join(stepsfile3_contents))

        chain = Chain(stepsfile3)
        expected_types = [Image, Pattern, Text]
        self.assertEqual([type(s) for s in chain._steps], expected_types)
Пример #2
0
    def test_hybrid_nomatch(self):
        finder = HybridFinder()
        finder.configure_backend("autopy")
        finder.synchronize_backend("autopy")
        finder.params["find"]["similarity"].value = 1.0
        matches = finder.find(Chain('circle_fake'), Image('all_shapes'))

        # verify match accuracy
        self.assertEqual(len(matches), 0)

        # verify dumped files count and names (4+4+7)
        dumps = self._verify_and_get_dumps(15, multistep=True)
Пример #3
0
    def _build_chain(self, stepsfile_contents, stepsfile=None):
        """
        Create an instance of :py:class:`guibot.target.Chain` to be used by the tests.

        :param str stepsfile_contents: contents for the stepsfile to be passed when creating the finder
        :param str stepsfile: name of the stepsfile to load or None to use the default
        :returns: an instance of the finder
        :rtype: :py:class:`finder.Finder`
        """
        filename = self._create_temp_file(prefix=self.stepsfile_name,
                                          extension=".steps",
                                          contents=stepsfile_contents)
        return Chain(os.path.splitext(filename)[0])
Пример #4
0
    def test_hybrid_multiconfig(self):
        finder = HybridFinder()
        finder.configure_backend("autopy")
        finder.synchronize_backend("autopy")
        finder.params["find"]["similarity"].value = 1.0
        matches = finder.find(Chain('circle'), Image('all_shapes'))

        # verify match accuracy
        self.assertEqual(len(matches), 1)
        self.assertEqual(matches[0].x, 104)
        self.assertEqual(matches[0].y, 10)

        # verify dumped files count and names (+1 as we match with template)
        dumps = self._verify_and_get_dumps(9, multistep=True)
Пример #5
0
    def test_stepsfile_lookup(self):
        """Test that the stepsfile will be searched using :py:class:`guibot.fileresolver.FileResolver`."""
        tmp_dir = mkdtemp()
        tmp_steps_file = "{}/{}.steps".format(tmp_dir, self.stepsfile_missing)
        with open(tmp_steps_file, "w") as fp:
            fp.write("image_for_autopy.png	some_autopy_matchfile.match")
        filename = os.path.basename(os.path.splitext(tmp_steps_file)[0])

        try:
            with patch("guibot.fileresolver.FileResolver.search",
                       wraps=lambda _: tmp_steps_file) as mock_search:
                Chain(self.stepsfile_missing)
                # but make sure we did search for the "missing" stepsfile
                mock_search.assert_any_call("{}.steps".format(filename))
        finally:
            os.unlink(tmp_steps_file)
            os.rmdir(tmp_dir)
Пример #6
0
    def test_hybrid_same(self):
        finder = HybridFinder()
        finder.configure_backend("autopy")
        finder.synchronize_backend("autopy")
        finder.params["find"]["similarity"].value = 1.0
        matches = finder.find(Chain('circle_simple'), Image('all_shapes'))

        # verify match accuracy
        self.assertEqual(len(matches), 1)
        self.assertEqual(matches[0].x, 104)
        self.assertEqual(matches[0].y, 10)

        # verify dumped files count and names
        dumps = self._verify_and_get_dumps(4)
        self._verify_dumped_images('shape_blue_circle', 'all_shapes', dumps,
                                   "autopy")
        self._verify_single_hotmap(dumps, "autopy")
Пример #7
0
    def test_step_save(self):
        """Test that dumping a chain to a file works and that the content is preserved."""
        # The Text target accepts either a file or a text string and we test
        # with both modes. For the first mode we need a real file.
        text_file = self._create_temp_file(prefix="some_text_file",
                                           extension=".txt")
        with open(text_file, "w") as fp:
            fp.write("ocr_string")

        # create real temp files for these -- they are saved using open() and we are not
        # mocking those calls. Also, the temp files will automatically be removed on tear down
        deep_csv = self._create_temp_file(prefix="item_for_deep",
                                          extension=".csv")
        cascade_xml = self._create_temp_file(prefix="item_for_cascade",
                                             extension=".xml")
        # no need to mock png files -- the Image target uses PIL.Image.save(), which we mocked

        # destination stepfile
        target_filename = self._create_temp_file(extension=".steps")

        stepsfile_contents = [
            "item_for_contour.png	some_contour_matchfile.match",
            "item_for_tempfeat.png	some_tempfeat_matchfile.match",
            "item_for_feature.png	some_feature_matchfile.match",
            "{}	some_deep_matchfile.match".format(deep_csv),
            "17	some_deep_matchfile.match",
            "{}	some_cascade_matchfile.match".format(cascade_xml),
            "item_for_template.png	some_template_matchfile.match",
            "item_for_autopy.png	some_autopy_matchfile.match",
            "{}	some_text_matchfile.match".format(
                os.path.splitext(text_file)[0]),
            "some_text_content	some_text_matchfile.match"
        ]

        expected_content = [
            "item_for_contour.png	item_for_contour.match",
            "item_for_tempfeat.png	item_for_tempfeat.match",
            "item_for_feature.png	item_for_feature.match",
            "{0}.csv	{0}.match".format(os.path.splitext(deep_csv)[0]),
            "17	17.match",
            "{0}.xml	{0}.match".format(os.path.splitext(cascade_xml)[0]),
            "item_for_template.png	item_for_template.match",
            "item_for_autopy.png	item_for_autopy.match",
            "{0}.txt	{0}.match".format(os.path.splitext(text_file)[0]),
            "some_text_content	some_text_content.match"
        ]

        source_stepsfile = self._create_temp_file(
            prefix=self.stepsfile_name,
            extension=".steps",
            contents=os.linesep.join(stepsfile_contents))

        FileResolver().add_path(os.path.dirname(text_file))
        try:
            chain = Chain(os.path.splitext(source_stepsfile)[0])
            chain.save(target_filename)

            with open(target_filename, "r") as f:
                generated_content = f.read().splitlines()

            # assert that the generated steps file has the expected content
            self.assertEqual(generated_content, expected_content)

            # build a list of the match filenames generated from
            # the calls to `Finder.to_match_file()`
            generated_match_names = []
            for c in self.mock_match_write.call_args_list:
                generated_match_names.append(c[0][1])

            # get a list
            expected_match_names = [x.split("\t")[1] for x in expected_content]
            expected_match_names.insert(
                0,
                os.path.splitext(source_stepsfile)[0] + ".match")

            # and assert that a match file was generated for each line
            # and for the steps file itself
            self.assertEqual(generated_match_names, expected_match_names)
        finally:
            FileResolver().remove_path(os.path.dirname(text_file))