Update checked in version of gsutil to version 4.6

third_party/boto/tests/unit/dynamodb2/test_table.py

 import mock
-import unittest
+from tests.unit import unittest
 from boto.dynamodb2 import exceptions
 from boto.dynamodb2.fields import (HashKey, RangeKey,
                                    AllIndex, KeysOnlyIndex, IncludeIndex,
                                    GlobalAllIndex, GlobalKeysOnlyIndex,
                                    GlobalIncludeIndex)
 from boto.dynamodb2.items import Item
 from boto.dynamodb2.layer1 import DynamoDBConnection
 from boto.dynamodb2.results import ResultSet, BatchGetResultSet
 from boto.dynamodb2.table import Table
-from boto.dynamodb2.types import (STRING, NUMBER,
+from boto.dynamodb2.types import (STRING, NUMBER, BINARY,
                                   FILTER_OPERATORS, QUERY_OPERATORS)
 from boto.exception import JSONResponseError
 
 
 FakeDynamoDBConnection = mock.create_autospec(DynamoDBConnection)
 
 
-
 class SchemaFieldsTestCase(unittest.TestCase):
     def test_hash_key(self):
         hash_key = HashKey('hello')
         self.assertEqual(hash_key.name, 'hello')
         self.assertEqual(hash_key.data_type, STRING)
         self.assertEqual(hash_key.attr_type, 'HASH')
 
         self.assertEqual(hash_key.definition(), {
             'AttributeName': 'hello',
             'AttributeType': 'S'
@@ skipping 261 matching lines @@
                     'gender',
                     'friend_count',
                 ]
             },
             'ProvisionedThroughput': {
                 'ReadCapacityUnits': 5,
                 'WriteCapacityUnits': 5
             }
         })
 
+    def test_global_include_index_throughput(self):
+        include_index = GlobalIncludeIndex('IncludeKeys', parts=[
+            HashKey('username'),
+            RangeKey('date_joined')
+        ], includes=[
+            'gender',
+            'friend_count'
+        ], throughput={
+            'read': 10,
+            'write': 8
+        })
+
+        self.assertEqual(include_index.schema(), {
+            'IndexName': 'IncludeKeys',
+            'KeySchema': [
+                {
+                    'AttributeName': 'username',
+                    'KeyType': 'HASH'
+                },
+                {
+                    'AttributeName': 'date_joined',
+                    'KeyType': 'RANGE'
+                }
+            ],
+            'Projection': {
+                'ProjectionType': 'INCLUDE',
+                'NonKeyAttributes': [
+                    'gender',
+                    'friend_count',
+                ]
+            },
+            'ProvisionedThroughput': {
+                'ReadCapacityUnits': 10,
+                'WriteCapacityUnits': 8
+            }
+        })
+
 
 class ItemTestCase(unittest.TestCase):
     def setUp(self):
         super(ItemTestCase, self).setUp()
         self.table = Table('whatever', connection=FakeDynamoDBConnection())
         self.johndoe = self.create_item({
             'username': 'johndoe',
             'first_name': 'John',
             'date_joined': 12345,
         })
@@ skipping 502 matching lines @@
     if exclusive_start_key + 5 < end_cap:
         retval['last_key'] = exclusive_start_key + 5
 
     return retval
 
 
 class ResultSetTestCase(unittest.TestCase):
     def setUp(self):
         super(ResultSetTestCase, self).setUp()
         self.results = ResultSet()
-        self.results.to_call(fake_results, 'john', greeting='Hello', limit=20)
+        self.result_function = mock.MagicMock(side_effect=fake_results)
+        self.results.to_call(self.result_function, 'john', greeting='Hello', limit=20)
 
     def test_first_key(self):
         self.assertEqual(self.results.first_key, 'exclusive_start_key')
 
+    def test_max_page_size_fetch_more(self):
+        self.results = ResultSet(max_page_size=10)
+        self.results.to_call(self.result_function, 'john', greeting='Hello')
+        self.results.fetch_more()
+        self.result_function.assert_called_with('john', greeting='Hello', limit=10)
+        self.result_function.reset_mock()
+
+    def test_max_page_size_and_smaller_limit_fetch_more(self):
+        self.results = ResultSet(max_page_size=10)
+        self.results.to_call(self.result_function, 'john', greeting='Hello', limit=5)
+        self.results.fetch_more()
+        self.result_function.assert_called_with('john', greeting='Hello', limit=5)
+        self.result_function.reset_mock()
+
+    def test_max_page_size_and_bigger_limit_fetch_more(self):
+        self.results = ResultSet(max_page_size=10)
+        self.results.to_call(self.result_function, 'john', greeting='Hello', limit=15)
+        self.results.fetch_more()
+        self.result_function.assert_called_with('john', greeting='Hello', limit=10)
+        self.result_function.reset_mock()
+
     def test_fetch_more(self):
         # First "page".
         self.results.fetch_more()
         self.assertEqual(self.results._results, [
             'Hello john #0',
             'Hello john #1',
             'Hello john #2',
             'Hello john #3',
             'Hello john #4',
         ])
 
+        self.result_function.assert_called_with('john', greeting='Hello', limit=20)
+        self.result_function.reset_mock()
+
         # Fake in a last key.
         self.results._last_key_seen = 4
         # Second "page".
         self.results.fetch_more()
         self.assertEqual(self.results._results, [
             'Hello john #5',
             'Hello john #6',
             'Hello john #7',
             'Hello john #8',
             'Hello john #9',
         ])
 
+        self.result_function.assert_called_with('john', greeting='Hello', limit=20, exclusive_start_key=4)
+        self.result_function.reset_mock()
+
         # Fake in a last key.
         self.results._last_key_seen = 9
         # Last "page".
         self.results.fetch_more()
         self.assertEqual(self.results._results, [
             'Hello john #10',
             'Hello john #11',
             'Hello john #12',
         ])
 
@@ skipping 221 matching lines @@
         raw_schema_1 = [
             {
                 "AttributeName": "username",
                 "KeyType": "HASH"
             },
             {
                 "AttributeName": "date_joined",
                 "KeyType": "RANGE"
             }
         ]
-        schema_1 = self.users._introspect_schema(raw_schema_1)
+        raw_attributes_1 = [
+            {
+                'AttributeName': 'username',
+                'AttributeType': 'S'
+            },
+            {
+                'AttributeName': 'date_joined',
+                'AttributeType': 'S'
+            },
+        ]
+        schema_1 = self.users._introspect_schema(raw_schema_1, raw_attributes_1)
         self.assertEqual(len(schema_1), 2)
         self.assertTrue(isinstance(schema_1[0], HashKey))
         self.assertEqual(schema_1[0].name, 'username')
         self.assertTrue(isinstance(schema_1[1], RangeKey))
         self.assertEqual(schema_1[1].name, 'date_joined')
 
         raw_schema_2 = [
             {
                 "AttributeName": "username",
                 "KeyType": "BTREE"
             },
         ]
+        raw_attributes_2 = [
+            {
+                'AttributeName': 'username',
+                'AttributeType': 'S'
+            },
+        ]
         self.assertRaises(
             exceptions.UnknownSchemaFieldError,
             self.users._introspect_schema,
-            raw_schema_2
+            raw_schema_2,
+            raw_attributes_2
         )
 
+        # Test a complex schema & ensure the types come back correctly.
+        raw_schema_3 = [
+            {
+                "AttributeName": "user_id",
+                "KeyType": "HASH"
+            },
+            {
+                "AttributeName": "junk",
+                "KeyType": "RANGE"
+            }
+        ]
+        raw_attributes_3 = [
+            {
+                'AttributeName': 'user_id',
+                'AttributeType': 'N'
+            },
+            {
+                'AttributeName': 'junk',
+                'AttributeType': 'B'
+            },
+        ]
+        schema_3 = self.users._introspect_schema(raw_schema_3, raw_attributes_3)
+        self.assertEqual(len(schema_3), 2)
+        self.assertTrue(isinstance(schema_3[0], HashKey))
+        self.assertEqual(schema_3[0].name, 'user_id')
+        self.assertEqual(schema_3[0].data_type, NUMBER)
+        self.assertTrue(isinstance(schema_3[1], RangeKey))
+        self.assertEqual(schema_3[1].name, 'junk')
+        self.assertEqual(schema_3[1].data_type, BINARY)
+
     def test__introspect_indexes(self):
         raw_indexes_1 = [
             {
                 "IndexName": "MostRecentlyJoinedIndex",
                 "KeySchema": [
                     {
                         "AttributeName": "username",
                         "KeyType": "HASH"
                     },
                     {
@@ skipping 467 matching lines @@
         with mock.patch.object(
                 self.users,
                 'get_item',
                 return_value=expected) as mock_get_item:
             self.users.lookup('johndoe', 1366056668)
 
         mock_get_item.assert_called_once_with(
             username= 'johndoe',
             date_joined= 1366056668)
 
-
     def test_put_item(self):
         with mock.patch.object(
                 self.users.connection,
                 'put_item',
                 return_value={}) as mock_put_item:
             self.users.put_item(data={
                 'username': 'johndoe',
                 'last_name': 'Doe',
                 'date_joined': 12345,
             })
@@ skipping 47 matching lines @@
                 return_value={}) as mock_delete_item:
             self.assertTrue(self.users.delete_item(username='johndoe', date_joined=23456))
 
         mock_delete_item.assert_called_once_with('users', {
             'username': {
                 'S': 'johndoe'
             },
             'date_joined': {
                 'N': '23456'
             }
-        })
+        }, expected=None, conditional_operator=None)
+
+    def test_delete_item_conditionally(self):
+        with mock.patch.object(
+                self.users.connection,
+                'delete_item',
+                return_value={}) as mock_delete_item:
+            self.assertTrue(self.users.delete_item(expected={'balance__eq': 0},
+                                                   username='johndoe', date_joined=23456))
+
+        mock_delete_item.assert_called_once_with('users', {
+            'username': {
+                'S': 'johndoe'
+            },
+            'date_joined': {
+                'N': '23456'
+            }
+        },
+        expected={
+            'balance': {
+                'ComparisonOperator': 'EQ', 'AttributeValueList': [{'N': '0'}]
+                },
+            },
+        conditional_operator=None)
+
+        def side_effect(*args, **kwargs):
+            raise exceptions.ConditionalCheckFailedException(400, '', {})
+
+        with mock.patch.object(
+                self.users.connection,
+                'delete_item',
+                side_effect=side_effect) as mock_delete_item:
+            self.assertFalse(self.users.delete_item(expected={'balance__eq': 0},
+                                                    username='johndoe', date_joined=23456))
 
     def test_get_key_fields_no_schema_populated(self):
         expected = {
             "Table": {
                 "AttributeDefinitions": [
                     {
                         "AttributeName": "username",
                         "AttributeType": "S"
                     },
                     {
@@ skipping 401 matching lines @@
                 reverse=True,
                 username__between=['aaa', 'mmm']
             )
             usernames = [res['username'] for res in results['results']]
             self.assertEqual(usernames, ['johndoe', 'jane', 'alice', 'bob'])
             self.assertEqual(len(results['results']), 4)
             self.assertEqual(results['last_key'], None)
 
         mock_query.assert_called_once_with('users',
             consistent_read=False,
-            scan_index_forward=True,
+            scan_index_forward=False,
             index_name=None,
             attributes_to_get=None,
             limit=4,
             key_conditions={
                 'username': {
                     'AttributeValueList': [{'S': 'aaa'}, {'S': 'mmm'}],
                     'ComparisonOperator': 'BETWEEN',
                 }
             },
-            select=None
+            select=None,
+            query_filter=None,
+            conditional_operator=None
         )
 
         # Now alter the expected.
         expected['LastEvaluatedKey'] = {
             'username': {
                 'S': 'johndoe',
             },
         }
 
         with mock.patch.object(
                 self.users.connection,
                 'query',
                 return_value=expected) as mock_query_2:
             results = self.users._query(
                 limit=4,
                 reverse=True,
                 username__between=['aaa', 'mmm'],
                 exclusive_start_key={
                     'username': 'adam',
                 },
-                consistent=True
+                consistent=True,
+                query_filter=None,
+                conditional_operator='AND'
             )
             usernames = [res['username'] for res in results['results']]
             self.assertEqual(usernames, ['johndoe', 'jane', 'alice', 'bob'])
             self.assertEqual(len(results['results']), 4)
             self.assertEqual(results['last_key'], {'username': 'johndoe'})
 
         mock_query_2.assert_called_once_with('users',
             key_conditions={
                 'username': {
                     'AttributeValueList': [{'S': 'aaa'}, {'S': 'mmm'}],
                     'ComparisonOperator': 'BETWEEN',
                 }
             },
             index_name=None,
             attributes_to_get=None,
-            scan_index_forward=True,
+            scan_index_forward=False,
             limit=4,
             exclusive_start_key={
                 'username': {
                     'S': 'adam',
                 },
             },
             consistent_read=True,
-            select=None
+            select=None,
+            query_filter=None,
+            conditional_operator='AND'
         )
 
     def test_private_scan(self):
         expected = {
             "ConsumedCapacity": {
                 "CapacityUnits": 0.5,
                 "TableName": "users"
             },
             "Count": 4,
             "Items": [
@@ skipping 41 matching lines @@
         mock_scan.assert_called_once_with('users',
             scan_filter={
                 'friend_count': {
                     'AttributeValueList': [{'N': '2'}],
                     'ComparisonOperator': 'LE',
                 }
             },
             limit=2,
             segment=None,
             attributes_to_get=None,
-            total_segments=None
+            total_segments=None,
+            conditional_operator=None
         )
 
         # Now alter the expected.
         expected['LastEvaluatedKey'] = {
             'username': {
                 'S': 'jane',
             },
         }
 
         with mock.patch.object(
@@ skipping 22 matching lines @@
                 }
             },
             limit=3,
             exclusive_start_key={
                 'username': {
                     'S': 'adam',
                 },
             },
             segment=None,
             attributes_to_get=None,
-            total_segments=None
+            total_segments=None,
+            conditional_operator=None
         )
 
     def test_query(self):
         items_1 = {
             'results': [
                 Item(self.users, data={
                     'username': 'johndoe',
                     'first_name': 'John',
                     'last_name': 'Doe',
                 }),
                 Item(self.users, data={
                     'username': 'jane',
                     'first_name': 'Jane',
                     'last_name': 'Doe',
                 }),
             ],
             'last_key': 'jane',
         }
 
-        results = self.users.query(last_name__eq='Doe')
+        results = self.users.query_2(last_name__eq='Doe')
         self.assertTrue(isinstance(results, ResultSet))
         self.assertEqual(len(results._results), 0)
         self.assertEqual(results.the_callable, self.users._query)
 
         with mock.patch.object(
                 results,
                 'the_callable',
                 return_value=items_1) as mock_query:
             res_1 = results.next()
             # Now it should be populated.
@@ skipping 33 matching lines @@
                 Item(self.users, data={
                     'username': 'johndoe',
                 }),
                 Item(self.users, data={
                     'username': 'jane',
                 }),
             ],
             'last_key': 'jane',
         }
 
-        results = self.users.query(last_name__eq='Doe',
+        results = self.users.query_2(last_name__eq='Doe',
                                    attributes=['username'])
         self.assertTrue(isinstance(results, ResultSet))
         self.assertEqual(len(results._results), 0)
         self.assertEqual(results.the_callable, self.users._query)
 
         with mock.patch.object(
                 results,
                 'the_callable',
                 return_value=items_1) as mock_query:
             res_1 = results.next()
@@ skipping 57 matching lines @@
                 return_value=items_2) as mock_scan_2:
             res_3 = results.next()
             # New results should have been found.
             self.assertEqual(len(results._results), 1)
             self.assertEqual(res_3['username'], 'zoeydoe')
 
             self.assertRaises(StopIteration, results.next)
 
         self.assertEqual(mock_scan_2.call_count, 1)
 
-
     def test_scan_with_specific_attributes(self):
         items_1 = {
             'results': [
                 Item(self.users, data={
                     'username': 'johndoe',
                 }),
                 Item(self.users, data={
                     'username': 'jane',
                 }),
             ],
@@ skipping 12 matching lines @@
             res_1 = results.next()
             # Now it should be populated.
             self.assertEqual(len(results._results), 2)
             self.assertEqual(res_1['username'], 'johndoe')
             self.assertEqual(res_1.keys(), ['username'])
             res_2 = results.next()
             self.assertEqual(res_2['username'], 'jane')
 
         self.assertEqual(mock_query.call_count, 1)
 
-
     def test_count(self):
         expected = {
             "Table": {
                 "AttributeDefinitions": [
                     {
                         "AttributeName": "username",
                         "AttributeType": "S"
                     }
                 ],
                 "ItemCount": 5,
@@ skipping 25 matching lines @@
                 "TableStatus": "ACTIVE"
             }
         }
 
         with mock.patch.object(
                 self.users,
                 'describe',
                 return_value=expected) as mock_count:
             self.assertEqual(self.users.count(), 5)
 
+    def test_query_count_simple(self):
+        expected_0 = {
+            'Count': 0.0,
+        }
+
+        expected_1 = {
+            'Count': 10.0,
+        }
+
+        with mock.patch.object(
+                self.users.connection,
+                'query',
+                return_value=expected_0) as mock_query:
+            results = self.users.query_count(username__eq='notmyname')
+            self.assertTrue(isinstance(results, int))
+            self.assertEqual(results, 0)
+        self.assertEqual(mock_query.call_count, 1)
+        self.assertIn('scan_index_forward', mock_query.call_args[1])
+        self.assertEqual(True, mock_query.call_args[1]['scan_index_forward'])
+        self.assertIn('limit', mock_query.call_args[1])
+        self.assertEqual(None, mock_query.call_args[1]['limit'])
+
+        with mock.patch.object(
+                self.users.connection,
+                'query',
+                return_value=expected_1) as mock_query:
+            results = self.users.query_count(username__gt='somename', consistent=True, scan_index_forward=False, limit=10)
+            self.assertTrue(isinstance(results, int))
+            self.assertEqual(results, 10)
+        self.assertEqual(mock_query.call_count, 1)
+        self.assertIn('scan_index_forward', mock_query.call_args[1])
+        self.assertEqual(False, mock_query.call_args[1]['scan_index_forward'])
+        self.assertIn('limit', mock_query.call_args[1])
+        self.assertEqual(10, mock_query.call_args[1]['limit'])
+
     def test_private_batch_get(self):
         expected = {
             "ConsumedCapacity": {
                 "CapacityUnits": 0.5,
                 "TableName": "users"
             },
             'Responses': {
                 'users': [
                     {
                         'username': {'S': 'alice'},
@@ skipping 158 matching lines @@
                 return_value=items_2) as mock_batch_get_2:
             res_3 = results.next()
             # New results should have been found.
             self.assertEqual(len(results._results), 1)
             self.assertEqual(res_3['username'], 'zoeydoe')
 
             self.assertRaises(StopIteration, results.next)
 
         self.assertEqual(mock_batch_get_2.call_count, 1)
         self.assertEqual(results._keys_left, [])