Exemple #1
0
    def test_items_delete_by_id(self):
        # Insert several items
        with self.s.begin():
            items = [
                models.Item(blob="blob3", user=self.u),
                models.Item(blob="blob4", user=self.u),
                models.Item(blob="blob5", user=self.u)
            ]
            api.item_create(self.s, items)

        # Delete first and last items only
        with self.s.begin():
            ids = [1, 3]
            api.item_delete_by_id(self.s, self.u, filter_ids=ids)

        # Check that only the second added item remains
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 1)
            self.assertEqual(items[0].blob, "blob4")

        # Clean up
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            api.item_delete(self.s, items)

        # Verify clean up successful
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 0)
Exemple #2
0
    def test_items_get_filter(self):
        # Insert several items
        with self.s.begin():
            items = [
                models.Item(blob="blob0", user=self.u),
                models.Item(blob="blob1", user=self.u),
                models.Item(blob="blob2", user=self.u)
            ]
            api.item_create(self.s, items)

        # Retrieve first and last items only
        with self.s.begin():
            ids = [1, 3]
            items = api.item_getall(self.s, self.u, filter_ids=ids)
            self.assertEqual(len(items), 2)
            self.assertEqual(items[0].blob, "blob0")
            self.assertEqual(items[1].blob, "blob2")

        # Clean up
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            api.item_delete(self.s, items)

        # Verify clean up successful
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 0)
Exemple #3
0
    def test_items_basic(self):
        # Verify item list empty initially and insert an item
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(items, [])
            item = models.Item(blob="blob", category_id=None, user=self.u)
            api.item_create(self.s, [item])

        # Retrieve and verify inserted item
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 1)
            self.assertEqual(items[0].blob, "blob")

        # Update the item
        with self.s.begin():
            item.blob = "new blob"
            api.item_update(self.s, [item])

        # Check the updated item
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 1)
            self.assertEqual(items[0].blob, "new blob")
            self.assertEqual(items[0].category_id, None)

        # Update item with valid category
        with self.s.begin():
            category = models.Category(name="blah", user=self.u)
            api.category_create(self.s, [category])
            item.category_id = 1
            api.item_update(self.s, [item])

        # Check the updated item
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 1)
            self.assertEqual(items[0].blob, "new blob")
            self.assertEqual(items[0].category_id, 1)
            self.assertIsNotNone(items[0].category)

        # Clean up
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            api.category_delete(self.s, categories, True)

        # Verify clean up successful
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            self.assertEqual(len(categories), 0)
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 0)
Exemple #4
0
    def test_update_phrase(self):
        config = opp_config.OppConfig(self.conf_filepath)

        # Add user
        utils.execute("opp-db --config_file %s add-user -uu -pp "
                      "--phrase=123456" % self.conf_filepath)

        old = aescipher.AESCipher("123456")
        new = aescipher.AESCipher("654321")

        # Add category and item using old passphrase
        session = api.get_scoped_session(config)
        category = models.Category(name=old.encrypt("cat1"))
        item = models.Item(name=old.encrypt("item1"),
                           url=old.encrypt("url1"),
                           account=old.encrypt("account1"),
                           username=old.encrypt("username1"),
                           password=old.encrypt("password1"),
                           blob=old.encrypt("blob1"))
        with session.begin():
            user = api.user_get_by_username(session, 'u')
            category.user = user
            item.user = user
            api.category_create(session, [category])
            api.item_create(session, [item])

        # Update passphrase
        utils.execute("opp-db --config_file %s update-phrase -uu -pp "
                      "--old_phrase=123456 --new_phrase=654321" %
                      self.conf_filepath)

        # Check data using new passphrase
        session = api.get_scoped_session(config)
        with session.begin():
            user = api.user_get_by_username(session, 'u')
            category = api.category_getall(session, user)[0]
            self.assertEqual(new.decrypt(category.name), "cat1")
            item = api.item_getall(session, user)[0]
            self.assertEqual(new.decrypt(item.name), "item1")
            self.assertEqual(new.decrypt(item.url), "url1")
            self.assertEqual(new.decrypt(item.account), "account1")
            self.assertEqual(new.decrypt(item.username), "username1")
            self.assertEqual(new.decrypt(item.password), "password1")
            self.assertEqual(new.decrypt(item.blob), "blob1")

        # Cleanup
        utils.execute("opp-db --config_file %s del-user -uu -pp"
                      " --remove_data" % self.conf_filepath)
        self._assert_user_does_not_exist('u')
Exemple #5
0
    def _do_put(self, phrase):
        """
        Create a list of items, given an array of item parameters, with
        option to specify auto-generation of common or unique passwords
        for each item.

        :param phrase: decryption passphrase

        :returns: success result along with array of newly created items
        """
        payload_dicts = [{
            'name': "items",
            'is_list': True,
            'required': True
        }, {
            'name': "auto_pass",
            'is_list': False,
            'required': False
        }, {
            'name': "unique",
            'is_list': False,
            'required': False
        }, {
            'name': "genopts",
            'is_list': False,
            'required': False
        }]
        item_list, auto_pass, unique, genopts = self._check_payload(
            payload_dicts)

        if auto_pass is True:
            # Retrieve words dictionary
            words = self._get_words(genopts)

            # Generate common password for all items
            if unique is not True:
                common_password = self._gen_pwd(words, genopts)

        cipher = aescipher.AESCipher(phrase)
        items = []
        for row in item_list:
            if auto_pass is True:
                if unique is True:
                    password = self._gen_pwd(words, genopts)
                else:
                    password = common_password
            else:
                password = None

            items.append(self.make_item(row, cipher, password))

        try:
            items = api.item_create(self.session, items)
            response = []
            for item in items:
                response.append(item.extract(cipher))
            return {'result': 'success', 'items': response}
        except Exception:
            raise bh.OppError("Unable to add new items to the database!")
Exemple #6
0
    def _do_put(self, phrase):
        item_list, error = self._check_payload(expect_list=True)
        if error:
            return error

        cipher = aescipher.AESCipher(phrase)
        items = []
        for row in item_list:
            # Extract various item data into a list
            name = self._parse_or_set_empty(row, 'name')
            url = self._parse_or_set_empty(row, 'url')
            account = self._parse_or_set_empty(row, 'account')
            username = self._parse_or_set_empty(row, 'username')
            password = self._parse_or_set_empty(row, 'password')
            blob = self._parse_or_set_empty(row, 'blob')
            category_id = self._parse_or_set_empty(row, 'category_id')
            full_row = [name, url, account, username, password, blob]

            try:
                # TODO: (alex) deteremine if ok to insert completely empty item
                encoded_row = [
                    base64.b64encode(x.encode()).decode() for x in full_row
                ]
                encrypted_blob = cipher.encrypt("~".join(encoded_row))
                [name, url, account, username, password,
                 blob] = self._chunk6(encrypted_blob.decode())
                items.append(
                    models.Item(name=name,
                                url=url,
                                account=account,
                                username=username,
                                password=password,
                                blob=blob,
                                category_id=category_id))
            except (AttributeError, TypeError):
                return self.error("Invalid item data in list!")

        try:
            api.item_create(items, session=self.session)
            return {'result': "success"}
        except Exception:
            return self.error("Unable to add new items to the database!")
Exemple #7
0
    def test_items_get_filter(self):
        # Insert several items
        items = [
            models.Item(blob="blob0"),
            models.Item(blob="blob1"),
            models.Item(blob="blob2")
        ]
        api.item_create(items, session=self.session)

        # Retrieve first and last items only
        ids = [1, 3]
        items = api.item_getall(filter_ids=ids, session=self.session)
        self.assertEqual(len(items), 2)
        self.assertEqual(items[0].blob, "blob0")
        self.assertEqual(items[1].blob, "blob2")

        # Clean up and verify
        items = api.item_getall(session=self.session)
        api.item_delete(items, session=self.session)
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 0)
Exemple #8
0
    def test_categories_access_by_user(self):
        # Verify category list empty initially, add a category and some items
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            self.assertEqual(categories, [])
            category = models.Category(name="name", user=self.u)
            api.category_create(self.s, [category])
            items = [
                models.Item(blob="item1", category_id=1, user=self.u),
                models.Item(blob="item2", category_id=1, user=self.u)
            ]
            api.item_create(self.s, items)

        # Retrieve and verify inserted category
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            self.assertEqual(len(categories), 1)
            self.assertEqual(categories[0].name, "name")
            self.assertEqual(len(categories[0].items), 2)

        # Add another user and retrieve it
        utils.execute("opp-db --config_file %s add-user -uu2 -pp "
                      "--phrase=123456" % self.conf_filepath)
        new_u = api.user_get_by_username(self.s, "u2")
        self.assertEqual(new_u.username, "u2")

        # Attempt to retrieve categories with new user
        with self.s.begin():
            new_categories = api.category_getall(self.s, new_u)
            self.assertEqual(len(new_categories), 0)

        # Clean up
        with self.s.begin():
            api.category_delete(self.s, categories, True)

        # Verify clean up successful
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            self.assertEqual(len(categories), 0)
Exemple #9
0
    def test_items_delete_by_id(self):
        # Insert several items
        items = [
            models.Item(blob="blob3"),
            models.Item(blob="blob4"),
            models.Item(blob="blob5")
        ]
        api.item_create(items, session=self.session)

        # Delete first and last items only
        ids = [1, 3]
        api.item_delete_by_id(filter_ids=ids, session=self.session)

        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 1)
        self.assertEqual(items[0].blob, "blob4")

        # Clean up and verify
        items = api.item_getall(session=self.session)
        api.item_delete(items, session=self.session)
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 0)
Exemple #10
0
    def test_items_access_by_user(self):
        # Verify item list empty initially and add some items
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(items, [])
            items = [
                models.Item(blob="item1", user=self.u),
                models.Item(blob="item2", user=self.u)
            ]
            api.item_create(self.s, items)

        # Retrieve and verify inserted items
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 2)
            self.assertEqual(items[0].blob, "item1")
            self.assertEqual(items[1].blob, "item2")

        # Add another user and retrieve it
        utils.execute("opp-db --config_file %s add-user -uu2 -pp "
                      "--phrase=123456" % self.conf_filepath)
        new_u = api.user_get_by_username(self.s, "u2")
        self.assertEqual(new_u.username, "u2")

        # Attempt to retrieve items with new user
        with self.s.begin():
            new_items = api.item_getall(self.s, new_u)
            self.assertEqual(len(new_items), 0)

        # Clean up
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            api.item_delete(self.s, items)

        # Verify clean up successful
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 0)
Exemple #11
0
    def test_items_basic(self):
        # Expect empty item list initially
        items = api.item_getall(session=self.session)
        self.assertEqual(items, [])

        # Insert and retrieve an item
        item = models.Item(blob="blob", category_id=None)
        api.item_create([item], session=self.session)
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 1)

        # Update and check the item
        item.blob = "new blob"
        item.category_id = 999
        api.item_update([item], session=self.session)
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 1)
        self.assertEqual(items[0].blob, "new blob")
        self.assertEqual(items[0].category_id, 999)

        # Update item with valid category
        category = models.Category(name="blah")
        api.category_create([category], session=self.session)
        item.category_id = 1
        api.item_update([item], session=self.session)
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 1)
        self.assertEqual(items[0].blob, "new blob")
        self.assertEqual(items[0].category_id, 1)
        self.assertIsNotNone(items[0].category)

        # Clean up and verify
        categories = api.category_getall(session=self.session)
        api.category_delete(categories, True, session=self.session)
        categories = api.category_getall(session=self.session)
        self.assertEqual(len(categories), 0)
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 0)
Exemple #12
0
    def test_categories_delete_cascade(self):
        # Create two categories
        with self.s.begin():
            categories = [
                models.Category(name="cat1", user=self.u),
                models.Category(name="cat2", user=self.u)
            ]
            api.category_create(self.s, categories)

        # Verify created categories
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            self.assertEqual(len(categories), 2)
            self.assertEqual(categories[0].name, "cat1")
            self.assertEqual(categories[1].name, "cat2")

        # Create 4 items
        with self.s.begin():
            items = [
                models.Item(blob="item1", category_id=1, user=self.u),
                models.Item(blob="item2", category_id=1, user=self.u),
                models.Item(blob="item3", category_id=2, user=self.u),
                models.Item(blob="item4", category_id=2, user=self.u)
            ]
            api.item_create(self.s, items)

        # Verify created items
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 4)

            i1, i2, i3, i4 = items

            self.assertEqual(i1.blob, "item1")
            self.assertEqual(i1.category_id, 1)
            self.assertIsNotNone(i1.category)
            self.assertEqual(i1.category.id, 1)

            self.assertEqual(i2.blob, "item2")
            self.assertEqual(i2.category_id, 1)
            self.assertIsNotNone(i2.category)
            self.assertEqual(i1.category.id, 1)

            self.assertEqual(i3.blob, "item3")
            self.assertEqual(i3.category_id, 2)
            self.assertIsNotNone(i3.category)
            self.assertEqual(i3.category.id, 2)

            self.assertEqual(i4.blob, "item4")
            self.assertEqual(i4.category_id, 2)
            self.assertIsNotNone(i4.category)
            self.assertEqual(i4.category.id, 2)

        # Delete category 1 with cascade
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            api.category_delete(self.s, categories[:1], cascade=True)

        # Verify only 1 category remains
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            self.assertEqual(len(categories), 1)
            self.assertEqual(categories[0].name, "cat2")

        # Verify items 1 & 2 were deleted through cascade action
        # and that items 3 & 4 remain unchanged
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 2)
            i3, i4 = items
            self.assertEqual(i3.blob, "item3")
            self.assertEqual(i3.category_id, 2)
            self.assertIsNotNone(i3.category)
            self.assertEqual(i3.category.id, 2)
            self.assertEqual(i4.blob, "item4")
            self.assertEqual(i4.category_id, 2)
            self.assertIsNotNone(i4.category)
            self.assertEqual(i4.category.id, 2)

        # Delete category 2 without cascade
        with self.s.begin():
            api.category_delete(self.s, categories, cascade=False)

        # Verify categories list is now empty
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            self.assertEqual(len(categories), 0)

        # Verify that items 3 & 4 have no category association
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 2)
            i3, i4 = items
            self.assertEqual(i3.blob, "item3")
            self.assertEqual(i3.category_id, None)
            self.assertIsNone(i3.category)
            self.assertEqual(i4.blob, "item4")
            self.assertEqual(i4.category_id, None)
            self.assertIsNone(i4.category)

        # Remove remaining category
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            api.category_delete(self.s, categories, True)

        # Verify categories list is now empty
        with self.s.begin():
            categories = api.category_getall(self.s, self.u)
            self.assertEqual(len(categories), 0)

        # Make sure items were NOT deleted despite cascade=True
        # because they have no category association
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 2)
            i3, i4 = items
            self.assertEqual(i3.blob, "item3")
            self.assertEqual(i3.category_id, None)
            self.assertIsNone(i3.category)
            self.assertEqual(i4.blob, "item4")
            self.assertEqual(i4.category_id, None)
            self.assertIsNone(i4.category)

        # Clean up remaining items
        with self.s.begin():
            api.item_delete(self.s, items)

        # Verify clean up successful
        with self.s.begin():
            items = api.item_getall(self.s, self.u)
            self.assertEqual(len(items), 0)
Exemple #13
0
    def test_categories_delete_cascade(self):
        # Insert categories
        categories = [
            models.Category(name="cat1"),
            models.Category(name="cat2")
        ]
        api.category_create(categories, session=self.session)

        # Verify categories
        categories = api.category_getall(session=self.session)
        self.assertEqual(len(categories), 2)
        self.assertEqual(categories[0].name, "cat1")
        self.assertEqual(categories[1].name, "cat2")

        # Insert items
        items = [
            models.Item(blob="item1", category_id=1),
            models.Item(blob="item2", category_id=1),
            models.Item(blob="item3", category_id=2),
            models.Item(blob="item4", category_id=2)
        ]
        api.item_create(items, session=self.session)

        # Verify items
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 4)

        i1, i2, i3, i4 = items

        self.assertEqual(i1.blob, "item1")
        self.assertEqual(i1.category_id, 1)
        self.assertIsNotNone(i1.category)
        self.assertEqual(i1.category.id, 1)

        self.assertEqual(i2.blob, "item2")
        self.assertEqual(i2.category_id, 1)
        self.assertIsNotNone(i2.category)
        self.assertEqual(i1.category.id, 1)

        self.assertEqual(i3.blob, "item3")
        self.assertEqual(i3.category_id, 2)
        self.assertIsNotNone(i3.category)
        self.assertEqual(i3.category.id, 2)

        self.assertEqual(i4.blob, "item4")
        self.assertEqual(i4.category_id, 2)
        self.assertIsNotNone(i4.category)
        self.assertEqual(i4.category.id, 2)

        # Delete category 1 with cascade
        api.category_delete(categories[:1], cascade=True, session=self.session)

        # Verify only 1 category remains
        categories = api.category_getall(session=self.session)
        self.assertEqual(len(categories), 1)
        self.assertEqual(categories[0].name, "cat2")

        # Verify items 1 & 2 were deleted through cascade action
        # and that items 3 & 4 remain unchanged
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 2)
        i3, i4 = items
        self.assertEqual(i3.blob, "item3")
        self.assertEqual(i3.category_id, 2)
        self.assertIsNotNone(i3.category)
        self.assertEqual(i3.category.id, 2)
        self.assertEqual(i4.blob, "item4")
        self.assertEqual(i4.category_id, 2)
        self.assertIsNotNone(i4.category)
        self.assertEqual(i4.category.id, 2)

        # Delete category 2 without cascade
        api.category_delete(categories, cascade=False, session=self.session)

        # Verify categories list is now empty
        categories = api.category_getall(session=self.session)
        self.assertEqual(len(categories), 0)

        # Verify that items 3 & 4 have no category association
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 2)
        i3, i4 = items
        self.assertEqual(i3.blob, "item3")
        self.assertEqual(i3.category_id, None)
        self.assertIsNone(i3.category)
        self.assertEqual(i4.blob, "item4")
        self.assertEqual(i4.category_id, None)
        self.assertIsNone(i4.category)

        # Clean up and verify
        categories = api.category_getall(session=self.session)
        api.category_delete(categories, True, session=self.session)
        categories = api.category_getall(session=self.session)
        self.assertEqual(len(categories), 0)

        items = api.item_getall(session=self.session)
        api.item_delete(items, session=self.session)
        items = api.item_getall(session=self.session)
        self.assertEqual(len(items), 0)