Example #1
0
    def setUp(self):
        super(TestResultset, self).setUp()
        self.Base = Mock()
        self.data = list(range(3))

        def iterate_mock(rs):
            for item in rs.data:
                yield item

        def prepare_resultset_mock(rs, args=None, kwargs=None):
            response = {"sample": 1}

            rs.response = response
            rs.count = len(self.data)

            data = self.data[rs._offset:]

            if rs._limit is not None:
                data = self.data[:rs._limit]

            rs.data = data

        self.Base.iterate = iterate_mock
        self.Base.prepare_resultset = prepare_resultset_mock

        self.rs = Resultset(base=self.Base)
        self.rs.base._cursor = lambda *a, **k: list(range(3))
    def setUp(self):
        super(TestResultset, self).setUp()
        self.Base = Mock()
        self.data = list(range(3))

        def iterate_mock(rs):
            for item in rs.data:
                yield item

        def prepare_resultset_mock(rs, args=None, kwargs=None):
            response = {"sample": 1}

            rs.response = response
            rs.count = len(self.data)

            data = self.data[rs._offset:]

            if rs._limit is not None:
                data = self.data[:rs._limit]

            rs.data = data

        self.Base.iterate = iterate_mock
        self.Base.prepare_resultset = prepare_resultset_mock

        self.rs = Resultset(base=self.Base)
        self.rs.base._cursor = lambda *a, **k: list(range(3))
Example #3
0
    def test_first_last_shourcut_exceed(self):
        def iterate_mock(arg):
            for item in []:
                yield item

        self.Base.iterate = iterate_mock

        rs = Resultset(base=self.Base)

        assert_equal(rs.first, None)
        assert_equal(rs.last, None)
Example #4
0
    def test_repr_large_resultset(self):
        dataset = list(range(self.rs.max_repr_items * 2))

        def iterate_large_dataset(rs):
            for item in dataset:
                yield item

        custom_base = Mock()
        custom_base.iterate = iterate_large_dataset

        assert_equal(
            str(Resultset(base=custom_base)),
            "<Resultset: {0}... more>".format(", ".join(
                [str(i) for i in dataset[:self.rs.max_repr_items + 1]])))
class TestResultset(TestsBase):
    def setUp(self):
        super(TestResultset, self).setUp()
        self.Base = Mock()
        self.data = list(range(3))

        def iterate_mock(rs):
            for item in rs.data:
                yield item

        def prepare_resultset_mock(rs, args=None, kwargs=None):
            response = {"sample": 1}

            rs.response = response
            rs.count = len(self.data)

            data = self.data[rs._offset:]

            if rs._limit is not None:
                data = self.data[:rs._limit]

            rs.data = data

        self.Base.iterate = iterate_mock
        self.Base.prepare_resultset = prepare_resultset_mock

        self.rs = Resultset(base=self.Base)
        self.rs.base._cursor = lambda *a, **k: list(range(3))

    def tearDown(self):
        pass

    def test_init(self):
        rs = Resultset(self.Base, 1, 2, field=True, field2=False)

        assert_equal(rs._args, (1, 2))
        assert_equal(rs._kwargs, {"field": True, "field2": False})

    def test_response(self):
        assert_equal(self.rs.response, None)

        test_value = {"value": 1}
        self.rs._response = test_value

        assert_equal(self.rs.response, test_value)

    def test_iter(self):
        assert_equal(
            [item for item in self.rs],
            self.data
        )

    def test_first_shortcut(self):
        assert_equal(
            self.rs.first,
            self.data[0]
        )

    def test_first_last_shourcut_exceed(self):

        def iterate_mock(arg):
            for item in []:
                yield item

        self.Base.iterate = iterate_mock

        rs = Resultset(base=self.Base)

        assert_equal(rs.first, None)
        assert_equal(rs.last, None)

    def test_offset(self):
        assert_equal(
            len([item for item in self.rs.offset(1)]),
            2
        )

    def test_limit(self):
        assert_equal(
            len([item for item in self.rs.limit(2)]),
            2
        )

    def test_data(self):
        assert_equal(self.rs.data, None)

        self.rs.data = 1

        assert_equal(self.rs.data, 1)

    def test_count_shortcut(self):
        assert_equal(self.rs.count, 3)

    def test_repr(self):
        assert_equal(
            str(self.rs),
            "<Resultset: {0}>".format(
                ", ".join([str(i) for i in self.data])
            )
        )

    def test_repr_large_resultset(self):
        dataset = list(range(self.rs.max_repr_items * 2))

        def iterate_large_dataset(rs):
            for item in dataset:
                yield item

        custom_base = Mock()
        custom_base.iterate = iterate_large_dataset

        assert_equal(
            str(Resultset(base=custom_base)),
            "<Resultset: {0}... more>".format(
                ", ".join([
                    str(i) for i in dataset[:self.rs.max_repr_items + 1]])
            )
        )
Example #6
0
    def test_init(self):
        rs = Resultset(self.Base, 1, 2, field=True, field2=False)

        assert_equal(rs._args, (1, 2))
        assert_equal(rs._kwargs, {"field": True, "field2": False})
Example #7
0
class TestResultset(TestsBase):
    def setUp(self):
        super(TestResultset, self).setUp()
        self.Base = Mock()
        self.data = list(range(3))

        def iterate_mock(rs):
            for item in rs.data:
                yield item

        def prepare_resultset_mock(rs, args=None, kwargs=None):
            response = {"sample": 1}

            rs.response = response
            rs.count = len(self.data)

            data = self.data[rs._offset:]

            if rs._limit is not None:
                data = self.data[:rs._limit]

            rs.data = data

        self.Base.iterate = iterate_mock
        self.Base.prepare_resultset = prepare_resultset_mock

        self.rs = Resultset(base=self.Base)
        self.rs.base._cursor = lambda *a, **k: list(range(3))

    def test_init(self):
        rs = Resultset(self.Base, 1, 2, field=True, field2=False)

        assert_equal(rs._args, (1, 2))
        assert_equal(rs._kwargs, {"field": True, "field2": False})

    def test_response(self):
        assert_equal(self.rs.response, None)

        test_value = {"value": 1}
        self.rs._response = test_value

        assert_equal(self.rs.response, test_value)

    def test_iter(self):
        assert_equal([item for item in self.rs], self.data)

    def test_first_shortcut(self):
        assert_equal(self.rs.first, self.data[0])

    def test_first_last_shourcut_exceed(self):
        def iterate_mock(arg):
            for item in []:
                yield item

        self.Base.iterate = iterate_mock

        rs = Resultset(base=self.Base)

        assert_equal(rs.first, None)
        assert_equal(rs.last, None)

    def test_offset(self):
        assert_equal(len([item for item in self.rs.offset(1)]), 2)

    def test_limit(self):
        assert_equal(len([item for item in self.rs.limit(2)]), 2)

    def test_data(self):
        assert_equal(self.rs.data, None)

        self.rs.data = 1

        assert_equal(self.rs.data, 1)

    def test_count_shortcut(self):
        assert_equal(self.rs.count, 3)

    def test_repr(self):
        assert_equal(
            str(self.rs),
            "<Resultset: {0}>".format(", ".join([str(i) for i in self.data])))

    def test_repr_large_resultset(self):
        dataset = list(range(self.rs.max_repr_items * 2))

        def iterate_large_dataset(rs):
            for item in dataset:
                yield item

        custom_base = Mock()
        custom_base.iterate = iterate_large_dataset

        assert_equal(
            str(Resultset(base=custom_base)),
            "<Resultset: {0}... more>".format(", ".join(
                [str(i) for i in dataset[:self.rs.max_repr_items + 1]])))