Beispiel #1
0
    def test_links(self, Page):
        page1 = Mock()
        page1.items = [1, 2, 3]
        page2 = Mock()
        page2.items = [4, 5, 6]
        page3 = Mock()
        page3.items = [7, 8]
        page1.previous = None
        page1.next = page2
        page2.previous = page1
        page2.next = page3
        page3.previous = page2
        page3.next = None

        Page.return_value = page1
        uri = '/a/uri'
        pagination = wac.Pagination(Resource1, uri, 25, page1)
        self.assertEqual(pagination.current, page1)

        for expected_page in [page2, page3]:
            page = pagination.next()
            self.assertEqual(page, expected_page)
            self.assertEqual(pagination.current, expected_page)
        page = pagination.next()
        self.assertEqual(page, None)
        self.assertEqual(pagination.current, expected_page)

        for expected_page in [page2, page1]:
            page = pagination.previous()
            self.assertEqual(page, expected_page)
            self.assertEqual(pagination.current, expected_page)
        page = pagination.previous()
        self.assertEqual(page, None)
        self.assertEqual(pagination.current, expected_page)
Beispiel #2
0
    def test_iter(self):
        page1 = Mock()
        page1.items = [1, 2, 3]
        page2 = Mock()
        page2.items = [4, 5, 6]
        page3 = Mock()
        page3.items = [7, 8]
        page4 = Mock()
        page4.items = [9]
        page1.next = page2
        page2.next = page3
        page3.next = page4
        page4.next = None

        with patch.object(Resource1.client, '_op') as _op:
            with patch.object(Resource1, 'page_cls') as page_cls:
                page_cls.return_value = page1
                resp = _op.return_value
                resp.data = {}

                page_cls.return_value = page1
                uri = '/a/uri'
                pagination = wac.Pagination(Resource1, uri, 25, None)
                pages = [p for p in pagination]
                self.assertEqual([page1, page2, page3, page4], pages)

                page_cls.return_value = page2
                uri = '/a/uri'
                pagination = wac.Pagination(Resource1, uri, 25, None)
                pages = [p for p in pagination]
                self.assertEqual([page2, page3, page4], pages)
Beispiel #3
0
    def test_iter(self, Page):
        page1 = Mock()
        page1.items = [1, 2, 3]
        page2 = Mock()
        page2.items = [4, 5, 6]
        page3 = Mock()
        page3.items = [7, 8]
        page4 = Mock()
        page4.items = [9]
        page1.next = page2
        page2.next = page3
        page3.next = page4
        page4.next = None

        Page.return_value = page1
        uri = "/a/uri"
        pagination = wac.Pagination(None, uri, 25)
        pages = [p for p in pagination]
        self.assertEqual([page1, page2, page3, page4], pages)

        Page.return_value = page2
        uri = "/a/uri"
        pagination = wac.Pagination(None, uri, 25)
        pages = [p for p in pagination]
        self.assertEqual([page2, page3, page4], pages)
Beispiel #4
0
    def test_links(self, Page):
        page1 = Mock()
        page1.items = [1, 2, 3]
        page2 = Mock()
        page2.items = [4, 5, 6]
        page3 = Mock()
        page3.items = [7, 8]
        page1.previous = None
        page1.next = page2
        page2.previous = page1
        page2.next = page3
        page3.previous = page2
        page3.next = None

        Page.return_value = page1
        uri = '/a/uri'
        pagination = wac.Pagination(Resource1, uri, 25, page1)
        self.assertEqual(pagination.current, page1)

        for expected_page in [page2, page3]:
            page = next(pagination)
            self.assertEqual(page, expected_page)
            self.assertEqual(pagination.current, expected_page)
        page = next(pagination)
        self.assertEqual(page, None)
        self.assertEqual(pagination.current, expected_page)

        for expected_page in [page2, page1]:
            page = pagination.previous()
            self.assertEqual(page, expected_page)
            self.assertEqual(pagination.current, expected_page)
        page = pagination.previous()
        self.assertEqual(page, None)
        self.assertEqual(pagination.current, expected_page)
Beispiel #5
0
    def test_iter(self):
        page1 = Mock()
        page1.items = [0, 1, 2, 3]
        page1.total = 10
        page2 = Mock()
        page2.items = [4, 5, 6, 7]
        page2.total = 10
        page3 = Mock()
        page3.items = [8, 9]
        page3.total = 10

        page1.next = page2
        page2.next = page3
        page3.next = None

        with patch.object(Resource1, 'page_cls') as page_cls:
            with patch.object(Resource1.client, '_op') as _op:
                page_cls.side_effect = [page1, page1, page2, page3]
                resp = _op.return_value
                resp.data = {
                    '_type': 'page',
                }
                uri = '/a/uri'
                q = wac.Query(Resource1, uri, 4)
                vs = [v for v in q]
                self.assertEqual(list(range(10)), vs)
Beispiel #6
0
    def test_iter(self):
        page1 = Mock()
        page1.items = [1, 2, 3]
        page2 = Mock()
        page2.items = [4, 5, 6]
        page3 = Mock()
        page3.items = [7, 8]
        page4 = Mock()
        page4.items = [9]
        page1.next = page2
        page2.next = page3
        page3.next = page4
        page4.next = None

        with patch.object(Resource1.client, '_op') as _op:
            with patch.object(Resource1, 'page_cls') as page_cls:
                page_cls.return_value = page1
                resp = _op.return_value
                resp.data = {
                }

                page_cls.return_value = page1
                uri = '/a/uri'
                pagination = wac.Pagination(Resource1, uri, 25, None)
                pages = [p for p in pagination]
                self.assertEqual([page1, page2, page3, page4], pages)

                page_cls.return_value = page2
                uri = '/a/uri'
                pagination = wac.Pagination(Resource1, uri, 25, None)
                pages = [p for p in pagination]
                self.assertEqual([page2, page3, page4], pages)
Beispiel #7
0
    def test_iter(self):
        page1 = Mock()
        page1.items = [0, 1, 2, 3]
        page1.total = 10
        page2 = Mock()
        page2.items = [4, 5, 6, 7]
        page2.total = 10
        page3 = Mock()
        page3.items = [8, 9]
        page3.total = 10

        page1.next = page2
        page2.next = page3
        page3.next = None

        with patch.object(Resource1, 'page_cls') as page_cls:
            with patch.object(Resource1.client, '_op') as _op:
                page_cls.side_effect = [page1, page1, page2, page3]
                resp = _op.return_value
                resp.data = {
                    '_type': 'page',
                }
                uri = '/a/uri'
                q = wac.Query(Resource1, uri, 4)
                vs = [v for v in q]
                self.assertEqual(range(10), vs)
Beispiel #8
0
    def test_issue_to_changelog(self):
        issue = Mock()
        issue.key = 'some key'
        issue.fields = Mock()
        issue.fields.created = '1986-07-21T00:00:00Z'

        issue.changelog = Mock()

        item1 = Mock()
        item1.field = 'status'
        item1.toString = 'To Do'
        history1 = Mock()
        history1.created = '2017-01-01T00:00:00Z'
        history1.items = [item1]

        item2 = Mock()
        item2.field = 'something else'
        item3 = Mock()
        item3.field = 'status'
        item3.toString = 'In Progress'
        history2 = Mock()
        history2.created = '2017-02-02T00:00:00Z'
        history2.items = [item2, item3]

        issue.changelog.histories = [history1, history2]
        self.assertEquals(
            issue_to_changelog(issue), {
                'key':
                'some key',
                'changelog':
                [(u'Created', parse_date('1986-07-21T00:00:00Z')),
                 (u'To Do', parse_date('2017-01-01T00:00:00Z')),
                 (u'In Progress', parse_date('2017-02-02T00:00:00Z'))]
            })
Beispiel #9
0
    def test_save_payment_arcs_command_mocked(self):
        command_with_item_forms = Mock()
        items = [
            PagSegItem(description='Python Birds',
                       price=Decimal('18.99'),
                       quantity=3),
            PagSegItem(description='Objetos Pythônicos',
                       price=Decimal('24.99'),
                       quantity=2,
                       reference=ndb.Key(PagSegItem, 10))
        ]
        command_with_item_forms.items = items

        ndb.put_multi(items)
        payment = mommy.save_one(PagSegPayment)
        command_with_item_forms.result = payment

        payment_owner = mommy.save_one(Node)
        save_payment_arcs_cmd = SavePaymentArcsCmd(payment_owner)
        CommandSequential(command_with_item_forms,
                          save_payment_arcs_cmd).execute()

        self.assertEqual(payment,
                         pagseguro_facade.search_payments(payment_owner)()[0])

        logs = SearchLogs(payment)()
        self.assertEqual(1, len(logs))
        self.assertEqual(STATUS_CREATED, logs[0].status)

        self.assertListEqual(items, SearchItems(payment)())
Beispiel #10
0
    def setup(self):
        self.config_module = Mock()
        self.config_module.listen_host = '127.0.0.1'
        self.config_module.listen_port = 10050
        self.config_module.item_files = list()

        self._patcher = patch('logging.config')
        self.mock_logging_conf = self._patcher.start()

        self.config_module.logging_conf = os.path.join(CONFIG_DIR,
                                                       'logging.conf')

        self.modules = {CONFIG_PATH: self.config_module}

        for i in range(ITEM_MODULES_COUNT):
            item_module = Mock()
            item_module.items = {str(i): lambda: i, OVERRIDDEN_KEY: lambda: i}

            item_module_path = os.path.join(ITEMS_DIR, "{0}.py".format(i))
            self.config_module.item_files.append(item_module_path)
            self.modules[item_module_path] = item_module

        def return_module(module_path):
            return self.modules[module_path]

        self.config_loader = Mock()
        self.config_loader.load.side_effect = return_module
        self.config_manager = ConfigManager(CONFIG_PATH, self.config_loader)
    def test_save_pagseguro_data(self):
        access_data = CreateOrUpdateAccessData('*****@*****.**', 'abc1234')()
        command_with_item_forms = Mock()
        command_with_item_forms.items = [PagSegItem(description='Python Birds', price=Decimal('18.99'), quantity=3),
                                         PagSegItem(description='Objetos Pythônicos', price=Decimal('24.99'),
                                                    quantity=2,
                                                    reference=ndb.Key(PagSegItem, 10))]
        address_form_mock = Mock()
        client_form_mock = Mock()
        command_with_item_forms.address_form = address_form_mock
        command_with_item_forms.client_form = client_form_mock
        command_with_item_forms.access_data = access_data

        save_pagseguro_data_cmd = SavePagseguroDataCmd()
        CommandSequential(command_with_item_forms, save_pagseguro_data_cmd).execute()

        items = PagSegItem.query().fetch()
        self.assertEqual(2, len(items))
        self.assertEqual(set(i.key for i in items), set(i.key for i in save_pagseguro_data_cmd.items))
        payment = PagSegPayment.query().get()
        self.assertIsNotNone(payment)
        self.assertEqual(payment, save_pagseguro_data_cmd.result)
        self.assertEqual(Decimal('106.95'), save_pagseguro_data_cmd.result.total,
                         'Total should be the some of the total of items')
        self.assertEqual('*****@*****.**', save_pagseguro_data_cmd.access_data.email)
        self.assertEqual('abc1234', save_pagseguro_data_cmd.access_data.token)

        # Data used for sequential commands
        self.assertEqual(save_pagseguro_data_cmd.address_form, address_form_mock)
        self.assertEqual(save_pagseguro_data_cmd.client_form, client_form_mock)
Beispiel #12
0
 def create_response(self):
     response = Mock()
     response.items = Mock(return_value = [('Content-Type', 'text/html; charset=utf-8')])
     response.status_code = 200
     response.reason_phrase = 'OK'
     response.content = "Hello, world. You're at the polls index."
     return response
    def test_save_item_arcs_command(self):
        command_with_item_forms = Mock()
        access_data = CreateOrUpdateAccessData('*****@*****.**', 'abc1234')()

        items = [PagSegItem(description='Python Birds', price=Decimal('18.99'), quantity=3),
                 PagSegItem(description='Objetos Pythônicos', price=Decimal('24.99'), quantity=2,
                            reference=ndb.Key(PagSegItem, 10))]
        command_with_item_forms.items = items

        address_form_mock = Mock()
        client_form_mock = Mock()

        command_with_item_forms.address_form = address_form_mock
        command_with_item_forms.client_form = client_form_mock
        command_with_item_forms.access_data = access_data

        ndb.put_multi(items)
        payment = mommy.save_one(PagSegPayment)
        command_with_item_forms.result = payment

        save_payment_to_items_arcs_cmd = SavePaymentToItemsArcs()
        CommandSequential(command_with_item_forms, save_payment_to_items_arcs_cmd).execute()

        self.assertListEqual(items, SearchItems(payment)())
        self.assertListEqual(items, save_payment_to_items_arcs_cmd.items)

        # Data used for sequential commands
        self.assertEqual('*****@*****.**', save_payment_to_items_arcs_cmd.access_data.email)
        self.assertEqual('abc1234', save_payment_to_items_arcs_cmd.access_data.token)
        self.assertEqual(save_payment_to_items_arcs_cmd.address_form, address_form_mock)
        self.assertEqual(save_payment_to_items_arcs_cmd.client_form, client_form_mock)
Beispiel #14
0
    def setup(self):
        self.config_module = Mock()
        self.config_module.listen_host = '0.0.0.0'
        self.config_module.listen_port = 10052
        self.config_module.item_files = list()

        self._patcher = patch('logging.config')
        self.mock_logging_conf = self._patcher.start()

        self.config_module.logging_conf = os.path.join(CONFIG_DIR,
                                                       'logging.conf')

        self.modules = {CONFIG_PATH: self.config_module}

        for i in range(ITEM_MODULES_COUNT):
            item_module = Mock()
            item_module.items = {str(i): lambda: i, OVERRIDDEN_KEY: lambda: i}

            item_module_path = os.path.join(ITEMS_DIR, "{0}.py".format(i))
            self.config_module.item_files.append(item_module_path)
            self.modules[item_module_path] = item_module

        def return_module(module_path):
            return self.modules[module_path]

        self.config_loader = Mock()
        self.config_loader.load.side_effect = return_module
        self.config_manager = ConfigManager(CONFIG_PATH, self.config_loader)
Beispiel #15
0
    def test_success(self, UrlFetchClassMock):
        # Mocking pagseguro Fetch
        UrlFetchClassMock.return_value = _build_mock()

        # Mocking previous command
        data_cmd_mock = Mock()
        data_cmd_mock.access_data.email = '*****@*****.**'
        data_cmd_mock.access_data.token = '4567890oiuytfgh'
        reference0 = ItemReferenceMock()
        reference1 = ItemReferenceMock()
        items = [PagSegItem(description='Python Course', price=Decimal('120'), quantity=1, reference=reference0.key),
                 PagSegItem(description='Another Python Course', price=Decimal('240'), quantity=2,
                            reference=reference1.key)]
        ndb.put_multi(items)
        data_cmd_mock.items = items
        data_cmd_mock.client_form = ValidateClientCmd(email='*****@*****.**', name='Jhon Doe').form
        data_cmd_mock.address_form = pagseguro_facade.validate_address_cmd('Rua 1', '2', 'meu bairro', '12345678',
                                                                              'São Paulo', 'SP', 'apto 4').form

        payment = PagSegPayment()
        payment.put()
        data_cmd_mock.result = payment

        contact_pagseguro_cmd = ContactPagseguro('https://store.com/pagseguro')
        CommandSequential(data_cmd_mock, contact_pagseguro_cmd).execute()

        self.assertEqual(payment, contact_pagseguro_cmd.result)
        self.assertEqual(payment.status, STATUS_SENT_TO_PAGSEGURO)
        self.assertEqual(contact_pagseguro_cmd.checkout_code, _SUCCESS_PAGSEGURO_CODE,
                         'Should have the code extracted from xml _PAGSEGURO_DETAIL_XML')
        self.assertIsNone(payment.code)
 def test_save_items(self):
     command_with_item_forms = Mock()
     command_with_item_forms.items = [PagSegItem(description='Python Birds', price=Decimal('18.99'), quantity=3),
                                      PagSegItem(description='Objetos Pythônicos', price=Decimal('24.99'),
                                                 quantity=2,
                                                 reference=ndb.Key(PagSegItem, 10))]
     save_items_cmd = SaveItemCmd()
     CommandSequential(command_with_item_forms, save_items_cmd).execute()
     items = PagSegItem.query().fetch()
     self.assertEqual(2, len(items))
     self.assertEqual(items, save_items_cmd.result)
Beispiel #17
0
    def test_suggest_when_method_set_but_invalid_and_header_field(self):
        args = Mock()
        args.method = 'http://example.com/'
        args.url = 'test:header'
        args.items = []

        self.httpie_argument_parser.suggest_method(args)

        self.assertEquals(args.method, 'GET')
        self.assertEquals(args.url, 'http://example.com/')
        self.assertEquals(args.items, [KeyValue(key='test', value='header', sep=':', orig='test:header')])
Beispiel #18
0
    def test_suggest_when_method_set_but_invalid_and_data_field(self):
        args = Mock()
        args.method = 'http://example.com/'
        args.url = 'data=field'
        args.items = []

        self.httpie_argument_parser.suggest_method(args)

        self.assertEquals(args.method, 'POST')
        self.assertEquals(args.url, 'http://example.com/')
        self.assertEquals(args.items, [KeyValue(key='data', value='field', sep='=', orig='data=field')])
Beispiel #19
0
    def test_suggest_when_method_not_set(self):
        args = Mock()
        args.method = None
        args.url = 'http://example.com/'
        args.items = []

        self.httpie_argument_parser.suggest_method(args)

        self.assertEquals(args.method, 'GET')
        self.assertEquals(args.url, 'http://example.com/')
        self.assertEquals(args.items, [])
Beispiel #20
0
    def test_suggest_when_method_set_but_invalid_and_item_exists(self):
        args = Mock()
        args.method = 'http://example.com/'
        args.url = 'new_item=a'
        args.items = [KeyValue(key='old_item', value='b', sep='=', orig='old_item=b')]

        self.httpie_argument_parser.suggest_method(args)

        self.assertEquals(args.items, [
            KeyValue(key='new_item', value='a', sep='=', orig='new_item=a'),
            KeyValue(key='old_item', value='b', sep='=', orig='old_item=b'),
        ])
Beispiel #21
0
    def test_iter(self):
        page1 = Mock()
        page1.items = [0, 1, 2, 3]
        page1.total = 10
        page2 = Mock()
        page2.items = [4, 5, 6, 7]
        page2.total = 10
        page3 = Mock()
        page3.items = [8, 9]
        page3.total = 10

        page1.next = page2
        page2.next = page3
        page3.next = None

        with patch("wac.Page") as Page:
            Page.side_effect = [page1, page1, page2, page3]
            uri = "/a/uri"
            q = wac.Query(None, uri, 4)
            vs = [v for v in q]
            self.assertEqual(range(10), vs)
Beispiel #22
0
 def test_config_options_cmd(self):
     cmd_options = {
         "host": "127.0.0.1",
         "port": "8080",
         "http_port": "5000,5001"
     }
     ini_parser = Mock()
     ini_parser.items = Mock(return_value=[])
     config = gen_config(self.config_field_info, ini_parser, cmd_options)
     self.assertEqual(config["host"], "127.0.0.1")
     self.assertIsInstance(config["port"], int)
     self.assertEqual(config["port"], 8080)
     self.assertIsInstance(config["http_port"], list)
     self.assertListEqual(config["http_port"], [5000, 5001])
Beispiel #23
0
def test_metric_initialization():
    fake_items = [("foo", "bar"), ("foobar", "baz")]

    fake_xpath = Mock(attrib={"name": "xpath_values"}, text="xpath_text")

    metric_mock = Mock()
    metric_mock.items = MagicMock(return_value=fake_items)
    metric_mock.findall = MagicMock(return_value=[fake_xpath])

    # When I create a metric with xpath
    m = Metric(metric_mock)

    # Then it should assign object attributes
    m.xpath_values.should.be("xpath_text")
    m.foo.should.be("bar")
    m.foobar.should.be("baz")
Beispiel #24
0
 def test_save_items(self):
     command_with_item_forms = Mock()
     command_with_item_forms.items = [
         PagSegItem(description='Python Birds',
                    price=Decimal('18.99'),
                    quantity=3),
         PagSegItem(description='Objetos Pythônicos',
                    price=Decimal('24.99'),
                    quantity=2,
                    reference=ndb.Key(PagSegItem, 10))
     ]
     save_items_cmd = SaveItemCmd()
     CommandSequential(command_with_item_forms, save_items_cmd).execute()
     items = PagSegItem.query().fetch()
     self.assertEqual(2, len(items))
     self.assertEqual(items, save_items_cmd.result)
Beispiel #25
0
 def setUp(self):
     self.pcmd = taskqueue.daemonlib.parse_cmdline
     opts = Mock()
     opts.foreground = True
     taskqueue.daemonlib.parse_cmdline = Mock(return_value=opts)
     self.config = ConfigParser()
     taskqueue.daemonlib.pika = Mock()
     fake_ctx = Mock()
     fake_ctx.__exit__ = Mock()
     fake_ctx.__enter__ = Mock()
     taskqueue.daemonlib.daemon.DaemonContext = Mock(return_value=fake_ctx)
     taskqueue.daemonlib.logging.config = Mock()
     config = Mock()
     config.items = Mock(return_value=[])
     taskqueue.daemonlib.ConfigParser = Mock(return_value=config)
     self.daemon = taskqueue.daemonlib.Daemon(self.config)
Beispiel #26
0
    def vms(self):
        metadata = Mock()
        metadata.name = "win-2016"
        metadata.namespace = "default"

        status = Mock()
        status.node_name = "master"

        vm = Mock()
        vm.metadata = metadata
        vm.status = status

        vms = Mock()
        vms.items = [vm]

        return vms
Beispiel #27
0
 def setUp(self):
     self.pcmd = taskqueue.daemonlib.parse_cmdline
     opts = Mock()
     opts.foreground = True
     taskqueue.daemonlib.parse_cmdline = Mock(return_value=opts)
     self.config = ConfigParser()
     taskqueue.daemonlib.pika = Mock()
     fake_ctx = Mock()
     fake_ctx.__exit__ = Mock()
     fake_ctx.__enter__ = Mock()
     taskqueue.daemonlib.daemon.DaemonContext = Mock(return_value=fake_ctx)
     taskqueue.daemonlib.logging.config = Mock()
     config = Mock()
     config.items = Mock(return_value=[])
     taskqueue.daemonlib.ConfigParser = Mock(return_value=config)
     self.daemon = taskqueue.daemonlib.Daemon(self.config)
Beispiel #28
0
    def test_save_item_arcs_command(self):
        command_with_item_forms = Mock()
        access_data = CreateOrUpdateAccessData('*****@*****.**', 'abc1234')()

        items = [
            PagSegItem(description='Python Birds',
                       price=Decimal('18.99'),
                       quantity=3),
            PagSegItem(description='Objetos Pythônicos',
                       price=Decimal('24.99'),
                       quantity=2,
                       reference=ndb.Key(PagSegItem, 10))
        ]
        command_with_item_forms.items = items

        address_form_mock = Mock()
        client_form_mock = Mock()

        command_with_item_forms.address_form = address_form_mock
        command_with_item_forms.client_form = client_form_mock
        command_with_item_forms.access_data = access_data

        ndb.put_multi(items)
        payment = mommy.save_one(PagSegPayment)
        command_with_item_forms.result = payment

        save_payment_to_items_arcs_cmd = SavePaymentToItemsArcs()
        CommandSequential(command_with_item_forms,
                          save_payment_to_items_arcs_cmd).execute()

        self.assertListEqual(items, SearchItems(payment)())
        self.assertListEqual(items, save_payment_to_items_arcs_cmd.items)

        # Data used for sequential commands
        self.assertEqual('*****@*****.**',
                         save_payment_to_items_arcs_cmd.access_data.email)
        self.assertEqual('abc1234',
                         save_payment_to_items_arcs_cmd.access_data.token)
        self.assertEqual(save_payment_to_items_arcs_cmd.address_form,
                         address_form_mock)
        self.assertEqual(save_payment_to_items_arcs_cmd.client_form,
                         client_form_mock)
Beispiel #29
0
    def test_success(self, UrlFetchClassMock):
        # Mocking pagseguro Fetch
        UrlFetchClassMock.return_value = _build_mock()

        # Mocking previous command
        data_cmd_mock = Mock()
        data_cmd_mock.access_data.email = '*****@*****.**'
        data_cmd_mock.access_data.token = '4567890oiuytfgh'
        reference0 = ItemReferenceMock()
        reference1 = ItemReferenceMock()
        items = [
            PagSegItem(description='Python Course',
                       price=Decimal('120'),
                       quantity=1,
                       reference=reference0.key),
            PagSegItem(description='Another Python Course',
                       price=Decimal('240'),
                       quantity=2,
                       reference=reference1.key)
        ]
        ndb.put_multi(items)
        data_cmd_mock.items = items
        data_cmd_mock.client_form = ValidateClientCmd(email='*****@*****.**',
                                                      name='Jhon Doe').form
        data_cmd_mock.address_form = pagseguro_facade.validate_address_cmd(
            'Rua 1', '2', 'meu bairro', '12345678', 'São Paulo', 'SP',
            'apto 4').form

        payment = PagSegPayment()
        payment.put()
        data_cmd_mock.result = payment

        contact_pagseguro_cmd = ContactPagseguro('https://store.com/pagseguro')
        CommandSequential(data_cmd_mock, contact_pagseguro_cmd).execute()

        self.assertEqual(payment, contact_pagseguro_cmd.result)
        self.assertEqual(payment.status, STATUS_SENT_TO_PAGSEGURO)
        self.assertEqual(
            contact_pagseguro_cmd.checkout_code, _SUCCESS_PAGSEGURO_CODE,
            'Should have the code extracted from xml _PAGSEGURO_DETAIL_XML')
        self.assertIsNone(payment.code)
Beispiel #30
0
def test_metric_initialization():
    """
    Create Metric object with xpath data
    """

    # When I have an Xpath object
    fake_items = [("foo", "bar"), ("foobar", "baz")]

    fake_xpath = Mock(attrib={"name": "xpath_values"}, text="xpath_text")

    metric_mock = Mock()
    metric_mock.items = MagicMock(return_value=fake_items)
    metric_mock.findall = MagicMock(return_value=[fake_xpath])

    # And I create a metric with that xpath object
    m = Metric(metric_mock)

    # Then it should assign object attributes
    m.xpath_values.should.be("xpath_text")
    m.foo.should.be("bar")
    m.foobar.should.be("baz")
Beispiel #31
0
    def test_save_pagseguro_data(self):
        access_data = CreateOrUpdateAccessData('*****@*****.**', 'abc1234')()
        command_with_item_forms = Mock()
        command_with_item_forms.items = [
            PagSegItem(description='Python Birds',
                       price=Decimal('18.99'),
                       quantity=3),
            PagSegItem(description='Objetos Pythônicos',
                       price=Decimal('24.99'),
                       quantity=2,
                       reference=ndb.Key(PagSegItem, 10))
        ]
        address_form_mock = Mock()
        client_form_mock = Mock()
        command_with_item_forms.address_form = address_form_mock
        command_with_item_forms.client_form = client_form_mock
        command_with_item_forms.access_data = access_data

        save_pagseguro_data_cmd = SavePagseguroDataCmd()
        CommandSequential(command_with_item_forms,
                          save_pagseguro_data_cmd).execute()

        items = PagSegItem.query().fetch()
        self.assertEqual(2, len(items))
        self.assertEqual(set(i.key for i in items),
                         set(i.key for i in save_pagseguro_data_cmd.items))
        payment = PagSegPayment.query().get()
        self.assertIsNotNone(payment)
        self.assertEqual(payment, save_pagseguro_data_cmd.result)
        self.assertEqual(Decimal('106.95'),
                         save_pagseguro_data_cmd.result.total,
                         'Total should be the some of the total of items')
        self.assertEqual('*****@*****.**',
                         save_pagseguro_data_cmd.access_data.email)
        self.assertEqual('abc1234', save_pagseguro_data_cmd.access_data.token)

        # Data used for sequential commands
        self.assertEqual(save_pagseguro_data_cmd.address_form,
                         address_form_mock)
        self.assertEqual(save_pagseguro_data_cmd.client_form, client_form_mock)
    def test_save_payment_arcs_command_mocked(self):
        command_with_item_forms = Mock()
        items = [PagSegItem(description='Python Birds', price=Decimal('18.99'), quantity=3),
                 PagSegItem(description='Objetos Pythônicos', price=Decimal('24.99'), quantity=2,
                            reference=ndb.Key(PagSegItem, 10))]
        command_with_item_forms.items = items

        ndb.put_multi(items)
        payment = mommy.save_one(PagSegPayment)
        command_with_item_forms.result = payment

        payment_owner = mommy.save_one(Node)
        save_payment_arcs_cmd = SavePaymentArcsCmd(payment_owner)
        CommandSequential(command_with_item_forms, save_payment_arcs_cmd).execute()

        self.assertEqual(payment, pagseguro_facade.search_payments(payment_owner)()[0])

        logs = SearchLogs(payment)()
        self.assertEqual(1, len(logs))
        self.assertEqual(STATUS_CREATED, logs[0].status)

        self.assertListEqual(items, SearchItems(payment)())
Beispiel #33
0
	def test_stateHandling(self):
		self.assertEqual(self.scope.topDown(), [self.actor])
		self.assertEqual(self.controlled.getScope(), self.scope)
		self.assertEqual(self.controlled.getScopedItems(), [self.actor])
		
		def f(a):
			raise OutputClosed()
		
		output = Mock()
		output.write = Mock(side_effect=f)
		
		self.assertRaises(OutputClosed, lambda: self.actor._handle(output, output))
		output.write.assert_called_once_with("hello")
		
		for x in self.controlled.getScopedItems():
			self.assertRaises(OutputClosed, lambda: x._handle(output, output))
		
		input = Mock()
		input.nouns = []
		input.items = []
		output = self.controlled.handle(input)
		
		self.assertEqual(output.text, "hello")
Beispiel #34
0
    def nodes(self):
        metadata = Mock()
        metadata.name = "master"

        node_info = Mock()
        node_info.machine_id = "52c01ad890e84b15a1be4be18bd64ecd"
        node_info.kubelet_version = "v1.9.1+a0ce1bc657"

        address = Mock()
        address.address = "master"

        status = Mock()
        status.node_info = node_info
        status.addresses = [address]
        status.allocatable = {"cpu": "2"}

        node = Mock()
        node.metadata = metadata
        node.status = status

        nodes = Mock()
        nodes.items = [node]

        return nodes
Beispiel #35
0
    def test_watch_with_decode(self):
        fake_resp = Mock()
        fake_resp.close = Mock()
        fake_resp.release_conn = Mock()

        expected_namespace_names = ('test1', 'test2', 'test3')

        block = Event()

        def list_namespace_chunked_mock(*args, **kwargs):
            print("list_namespace_list_or_watch_mock called", args, kwargs)

            for test_namespace in expected_namespace_names:
                event = {
                    "type": "ADDED",
                    "object": {
                        "api_version": "v1",
                        "kind": "Namespace",
                        "metadata": {
                            "name": test_namespace,
                            "selfLink": "/api/v1/namespaces/" + test_namespace,
                            "uid": test_namespace
                        }
                    }
                }
                body = json.dumps(event) + '\n'
                print("Dumping body", body)
                yield body

            # Hang the read
            time.sleep(1)
            if block.wait(timeout=10):
                raise ValueError("Timeout without clean closure")

        fake_resp.items = []  # Empty initial list
        fake_resp.read_chunked = Mock(side_effect=list_namespace_chunked_mock)

        fake_api = Mock()
        fake_api.list_namespace = Mock(return_value=fake_resp)
        fake_api.list_namespace.__doc__ = ':return: V1NamespaceList'  # The PYDOC_RETURN_LABEL used by

        w = Informer(fake_api.list_namespace)

        with w:
            time.sleep(1)  # let it prime asynchronously
            snapshot_items = w.items
            print("Done capturing items from informer", len(snapshot_items))

        # Stop hanging the read
        block.set()

        # Content
        assert all([_.kind == 'Namespace' for _ in snapshot_items])
        obtained_namespace_names = tuple(
            [_.metadata.name for _ in snapshot_items])
        assert obtained_namespace_names == expected_namespace_names

        # Was the list_namespace() mock, aka list_namespace_chunked_mock, invoked with expected values?
        # Cannot use fake_api.list_namespace.assert_called_with(_preload_content=False, watch=True), as timeout_seconds and resource_version may also be passed
        call_args, call_kwargs = fake_api.list_namespace.call_args
        assert call_kwargs['watch'] is True
        assert call_kwargs['_preload_content'] is False

        fake_resp.read_chunked.assert_called_once_with(decode_content=False)
        fake_resp.close.assert_called()
        fake_resp.release_conn.assert_called_once()
    """
    Small helper class to represent expected nexus data format
    """

    def __init__(self, data):
        self.data = data

    def get(self, _):
        mock_value = Mock()
        mock_value.value = self.data
        return mock_value


# nexusformat mock objects
NXLOAD_MOCK = Mock()
NXLOAD_MOCK.items = Mock(return_value=[('raw_data_1', DataHolder([b'1910232']))])

NXLOAD_MOCK_EMPTY = Mock()
NXLOAD_MOCK_EMPTY.items = Mock(return_value=[('raw_data_1', DataHolder(['']))])


# pylint:disable=missing-docstring,no-self-use,too-many-public-methods
class TestRunDetection(unittest.TestCase):
    def tearDown(self):
        if os.path.isfile('test_lastrun.txt'):
            os.remove('test_lastrun.txt')
        if os.path.isfile('test_summary.txt'):
            os.remove('test_summary.txt')
        if os.path.isfile('test_last_runs.csv'):
            os.remove('test_last_runs.csv')