コード例 #1
0
ファイル: test_app_database.py プロジェクト: xa7YvcR3/WALKOFF
 def setUp(self):
     self.device1 = Device('test1', [], [], 'type1')
     self.device2 = Device('test2', [], [], 'type1')
     self.device3 = Device('test3', [], [], 'type2')
     self.device4 = Device('test4', [], [], 'type2')
     self.all_devices = [
         self.device1, self.device2, self.device3, self.device4
     ]
コード例 #2
0
 def test_update_from_json_type_only(self):
     plaintext_fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
     encrypted_fields = [EncryptedDeviceField('test3', 'boolean', True),
                         EncryptedDeviceField('test4', 'string', 'something else')]
     device = Device('test', plaintext_fields, encrypted_fields, 'type', description='desc')
     device.update_from_json({'type': 'new_type'})
     self.assertConstructionIsCorrect(device, 'test', plaintext_fields, encrypted_fields, 'new_type',
                                      description='desc')
コード例 #3
0
 def test_delete_device(self):
     device1 = Device('test', [], [], 'type')
     device2 = Device('test2', [], [], 'type')
     device_db.session.add(device2)
     device_db.session.add(device1)
     device_db.session.commit()
     device1_id = device1.id
     self.delete_with_status_check('/api/devices/{}'.format(device1_id), headers=self.headers, status_code=SUCCESS)
     self.assertIsNone(device_db.session.query(Device).filter(Device.id == device1_id).first())
コード例 #4
0
 def test_update_device_app_dne(self):
     device1 = Device('test', [], [], 'type')
     device2 = Device('test2', [], [], 'type')
     device_db.session.add(device2)
     device_db.session.add(device1)
     device_db.session.commit()
     data = {'id': device1.id, 'name': 'renamed', 'app_name': 'Invalid'}
     self.post_with_status_check('/api/devices', headers=self.headers, data=json.dumps(data),
                                 status_code=INVALID_INPUT_ERROR, content_type='application/json')
コード例 #5
0
 def test_read_device(self):
     device1 = Device('test', [], [], 'type')
     device2 = Device('test2', [], [], 'type')
     device_db.session.add(device2)
     device_db.session.add(device1)
     device_db.session.commit()
     response = self.get_with_status_check('/api/devices/{}'.format(device1.id), headers=self.headers,
                                           status_code=SUCCESS)
     expected_device1 = device1.as_json()
     expected_device1['app_name'] = ''
     self.assertEqual(response, expected_device1)
コード例 #6
0
 def test_as_json(self):
     plaintext_fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
     encrypted_fields = [EncryptedDeviceField('test3', 'boolean', True),
                         EncryptedDeviceField('test4', 'string', 'something else')]
     device = Device('test', plaintext_fields, encrypted_fields, 'type', description='desc')
     device_json = device.as_json()
     self.assertEqual(device_json['name'], 'test')
     self.assertEqual(device_json['type'], 'type')
     self.assertEqual(device_json['description'], 'desc')
     plaintext_fields.extend(encrypted_fields)
     for field in plaintext_fields:
         self.assertIn(field.as_json(), device_json['fields'])
コード例 #7
0
    def setUp(self):
        self.app_name = 'TestApp'
        self.app = walkoff.server.flaskserver.app.test_client(self)
        self.app.testing = True

        self.context = walkoff.server.flaskserver.app.test_request_context()
        self.context.push()

        self.device1 = Device('test1', [], [], 'type1')
        self.device2 = Device('test2', [], [], 'type1')
        self.device3 = Device('test3', [], [], 'type2')
        self.device4 = Device('test4', [], [], 'type2')
コード例 #8
0
 def test_update_from_json_with_plaintext_fields(self):
     plaintext_fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
     encrypted_fields = [EncryptedDeviceField('test3', 'boolean', True),
                         EncryptedDeviceField('test4', 'string', 'something else')]
     new_plaintext_fields = [DeviceField('new_test_name', 'integer', 451),
                             DeviceField('new_test2', 'string', 'changed')]
     device = Device('test', plaintext_fields, encrypted_fields, 'type', description='desc')
     device.update_from_json({'fields': [field.as_json() for field in new_plaintext_fields]})
     self.assertEqual(device.name, 'test')
     self.assertEqual(device.type, 'type')
     self.assertEqual(device.description, 'desc')
     self.assertSetEqual({field.name for field in device.plaintext_fields}, {'new_test_name', 'new_test2'})
     self.assertSetEqual({field.name for field in device.encrypted_fields}, set())
コード例 #9
0
    def test_update_device_type_dne(self):
        device1 = Device('test', [], [], 'type')
        device2 = Device('test2', [], [], 'type')
        app = App(name=self.test_app_name, devices=[device1, device2])
        device_db.session.add(app)
        device_db.session.commit()

        fields_json = [{'name': 'test_name', 'type': 'integer', 'encrypted': False},
                       {'name': 'test2', 'type': 'string', 'encrypted': False}]
        walkoff.config.config.app_apis = {self.test_app_name: {'devices': {'test_type': {'fields': fields_json}}}}

        data = {'id': device1.id, 'name': 'renamed', 'app_name': self.test_app_name, 'type': 'Invalid'}
        self.post_with_status_check('/api/devices', headers=self.headers, data=json.dumps(data),
                                    status_code=INVALID_INPUT_ERROR, content_type='application/json')
コード例 #10
0
    def test_from_json(self):
        plaintext_fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
        encrypted_field1 = EncryptedDeviceField('test3', 'boolean', True)
        encrypted_field2 = EncryptedDeviceField('test4', 'string', 'something else')
        encrypted_fields = [encrypted_field1, encrypted_field2]

        encrypted_field_json1 = encrypted_field1.as_json()
        encrypted_field_json2 = encrypted_field2.as_json()
        encrypted_field_json1_with_value = dict(encrypted_field_json1)
        encrypted_field_json2_with_value = dict(encrypted_field_json2)
        encrypted_field_json1_with_value['value'] = True
        encrypted_field_json2_with_value['value'] = 'something_else'

        fields_json = [field.as_json() for field in plaintext_fields]
        fields_json.extend([encrypted_field_json1_with_value, encrypted_field_json2_with_value])

        device = Device.from_json({'name': 'test', 'fields': fields_json, 'type': 'something', 'description': 'desc'})

        expected_plaintext_fields_as_json = [field.as_json() for field in plaintext_fields]
        expected_encrypted_fields_as_json = [field.as_json() for field in encrypted_fields]

        self.assertEqual(device.name, 'test')
        self.assertEqual(device.type, 'something')
        self.assertEqual(device.description, 'desc')
        for field in device.plaintext_fields:
            self.assertIn(field.as_json(), expected_plaintext_fields_as_json)
        for field in device.encrypted_fields:
            self.assertIn(field.as_json(), expected_encrypted_fields_as_json)
コード例 #11
0
ファイル: devices.py プロジェクト: xa7YvcR3/WALKOFF
def import_device(app, device, device_type, fields):
    try:
        device_api = get_app_device_api(app, device_type)
        device_fields_api = device_api['fields']
        validate_device_fields(device_fields_api, fields, device_type, app)
    except UnknownDevice:
        current_app.logger.error('Cannot import device for app {0}, type {1}. '
                                 'Type does not exist'.format(
                                     app, device_type))
    except InvalidArgument as e:
        current_app.logger.error('Cannot import device for app {0}, type {1}. '
                                 'Invalid input'.format(
                                     app, device_type,
                                     format_exception_message(e)))
    else:
        fields = device['fields']
        add_configuration_keys_to_device_json(fields, device_fields_api)
        app = device_db.session.query(App).filter(App.name == app).first()
        if app is not None:
            device_obj = Device.from_json(device)
            app.add_device(device_obj)
            device_db.session.add(device_obj)
            device_db.session.commit()
        else:
            current_app.logger.error(
                'SEVERE: App defined in api does not have corresponding entry in database. '
                'Cannot import device')
    return app
コード例 #12
0
 def test_create_device_device_already_exists(self):
     device1 = Device('test', [], [], 'type', description='description')
     device_db.session.add(device1)
     device_db.session.commit()
     device_json = {'app_name': 'test', 'name': 'test', 'type': 'some_type', 'fields': []}
     self.put_with_status_check('/api/devices', headers=self.headers, data=json.dumps(device_json),
                                status_code=OBJECT_EXISTS_ERROR, content_type='application/json')
コード例 #13
0
 def test_update_from_json_with_encrypted_fields(self):
     plaintext_fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
     encrypted_fields = [EncryptedDeviceField('test3', 'boolean', True),
                         EncryptedDeviceField('test4', 'string', 'something else')]
     new_encrypted_fields = [EncryptedDeviceField('new_test3', 'boolean', True),
                             EncryptedDeviceField('new_test4', 'string', 'something else')]
     encrypted_field_json1 = new_encrypted_fields[0].as_json()
     encrypted_field_json2 = new_encrypted_fields[1].as_json()
     encrypted_field_json1['value'] = True
     encrypted_field_json2['value'] = 'something_else'
     device = Device('test', plaintext_fields, encrypted_fields, 'type', description='desc')
     device.update_from_json({'fields': [encrypted_field_json1, encrypted_field_json2]})
     self.assertEqual(device.name, 'test')
     self.assertEqual(device.type, 'type')
     self.assertEqual(device.description, 'desc')
     self.assertSetEqual({field.name for field in device.plaintext_fields}, set())
     self.assertSetEqual({field.name for field in device.encrypted_fields}, {'new_test3', 'new_test4'})
コード例 #14
0
ファイル: test_app_base.py プロジェクト: xa7YvcR3/WALKOFF
    def setUp(self):
        self.test_app_name = 'TestApp'
        self.device1 = Device('test', [], [], 'type1')
        plaintext_fields = [
            DeviceField('test_name', 'integer', 123),
            DeviceField('test2', 'string', 'something')
        ]
        encrypted_fields = [
            EncryptedDeviceField('test3', 'boolean', True),
            EncryptedDeviceField('test4', 'string', 'something else')
        ]
        self.device2 = Device('test2', plaintext_fields, encrypted_fields,
                              'type2')
        self.db_app = App(name=self.test_app_name,
                          devices=[self.device1, self.device2])

        device_db.session.add(self.db_app)
        device_db.session.commit()
コード例 #15
0
    def test_update_device_fields(self):
        device1 = Device('test', [], [], 'type')
        device2 = Device('test2', [], [], 'type')
        app = App(name=self.test_app_name, devices=[device1, device2])
        device_db.session.add(app)
        device_db.session.commit()

        fields_json = [{'name': 'test_name', 'type': 'integer', 'encrypted': False},
                       {'name': 'test2', 'type': 'string', 'encrypted': False}]
        walkoff.config.config.app_apis = {self.test_app_name: {'devices': {'test_type': {'fields': fields_json}}}}

        fields_json = [{'name': 'test_name', 'value': 123}, {'name': 'test2', 'value': 'something'}]

        data = {'id': device1.id, 'name': 'renamed', 'app_name': self.test_app_name, 'type': 'test_type',
                'fields': fields_json}
        self.post_with_status_check('/api/devices', headers=self.headers, data=json.dumps(data),
                                    status_code=SUCCESS, content_type='application/json')

        self.assertEqual(device1.name, 'renamed')
        self.assertEqual(device1.get_plaintext_fields(), {field['name']: field['value'] for field in fields_json})
コード例 #16
0
ファイル: test_app_database.py プロジェクト: xa7YvcR3/WALKOFF
class TestAppDatabase(unittest.TestCase):
    def setUp(self):
        self.device1 = Device('test1', [], [], 'type1')
        self.device2 = Device('test2', [], [], 'type1')
        self.device3 = Device('test3', [], [], 'type2')
        self.device4 = Device('test4', [], [], 'type2')
        self.all_devices = [
            self.device1, self.device2, self.device3, self.device4
        ]

    def assertConstructionIsCorrect(self, app, name, devices):
        self.assertEqual(app.name, name)
        self.assertSetEqual({device.name for device in app.devices}, devices)

    def test_init_name_only(self):
        app = App('test')
        self.assertConstructionIsCorrect(app, 'test', set())

    def test_init_with_devices(self):
        app = App('test', devices=self.all_devices)
        self.assertConstructionIsCorrect(app, 'test',
                                         {'test1', 'test2', 'test3', 'test4'})

    def test_get_device(self):
        app = App('test', devices=self.all_devices)
        self.assertEqual(
            app.get_device('test2').as_json(), self.device2.as_json())

    def test_get_device_invalid(self):
        app = App('test', devices=self.all_devices)
        self.assertIsNone(app.get_device('invalid'))

    def test_as_json(self):
        app = App('test', devices=self.all_devices)
        app_json = app.as_json(with_devices=True)
        self.assertEqual(app_json['name'], 'test')
        expected_devices_json = [device.as_json() for device in app.devices]
        for device in app_json['devices']:
            self.assertIn(device, expected_devices_json)

    def test_add_device(self):
        app = App('test', devices=[self.device1, self.device2, self.device3])
        app.add_device(self.device4)
        self.assertSetEqual({device.name
                             for device in app.devices},
                            {'test1', 'test2', 'test3', 'test4'})

    def test_add_device_already_exists(self):
        app = App('test', devices=[self.device1, self.device2, self.device3])
        app.add_device(self.device3)
        self.assertSetEqual({device.name
                             for device in app.devices},
                            {'test1', 'test2', 'test3'})
コード例 #17
0
    def test_construct_fields_from_json(self):
        plaintext_fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
        encrypted_field1 = EncryptedDeviceField('test3', 'boolean', True)
        encrypted_field2 = EncryptedDeviceField('test4', 'string', 'something else')

        encrypted_field_json1 = encrypted_field1.as_json()
        encrypted_field_json2 = encrypted_field2.as_json()
        encrypted_field_json1['value'] = True
        encrypted_field_json2['value'] = 'something_else'
        fields_json = [field.as_json() for field in plaintext_fields]
        fields_json.extend([encrypted_field_json1, encrypted_field_json2])

        plaintext_fields, encrypted_fields = Device._construct_fields_from_json(fields_json)
        self.assertSetEqual({field.name for field in plaintext_fields}, {'test_name', 'test2'})
        self.assertSetEqual({field.name for field in encrypted_fields}, {'test3', 'test4'})
コード例 #18
0
 def test_read_all_devices(self):
     device1 = Device('test', [], [], 'type')
     device2 = Device('test2', [], [], 'type')
     app = App(name=self.test_app_name, devices=[device1, device2])
     device_db.session.add(app)
     device_db.session.commit()
     response = self.get_with_status_check('/api/devices', headers=self.headers, status_code=SUCCESS)
     expected_device1 = device1.as_json()
     expected_device1['app_name'] = 'TestApp'
     expected_device2 = device2.as_json()
     expected_device2['app_name'] = 'TestApp'
     self.assertIn(expected_device1, response)
     self.assertIn(expected_device2, response)
コード例 #19
0
ファイル: devices.py プロジェクト: xa7YvcR3/WALKOFF
    def __func():
        add_device_json = request.get_json()
        if device_db.session.query(Device).filter(
                Device.name == add_device_json['name']).first() is not None:
            current_app.logger.error('Could not create device {0}. '
                                     'Device already exists.'.format(
                                         add_device_json['name']))
            return {"error": "Device already exists."}, OBJECT_EXISTS_ERROR

        fields = {
            field['name']: field['value']
            for field in add_device_json['fields']
        }
        app = add_device_json['app_name']
        device_type = add_device_json['type']
        try:
            device_api = get_app_device_api(app, device_type)
            device_fields_api = device_api['fields']
            validate_device_fields(device_fields_api, fields, device_type, app)
        except (UnknownApp, UnknownDevice, InvalidArgument) as e:
            return __crud_device_error_handler('create', e, app, device_type)
        else:
            fields = add_device_json['fields']
            add_configuration_keys_to_device_json(fields, device_fields_api)
            app = device_db.session.query(App).filter(App.name == app).first()
            if app is None:
                current_app.logger.error(
                    'SEVERE: App defined in api does not have corresponding entry in database. '
                    'Cannot add device')
                return {'error': 'Unknown app'}, INVALID_INPUT_ERROR
            device = Device.from_json(add_device_json)
            app.add_device(device)
            device_db.session.add(device)
            device_db.session.commit()
            device_json = get_device_json_with_app_name(device)
            # remove_configuration_keys_from_device_json(device_json)
            return device_json, OBJECT_CREATED
コード例 #20
0
 def test_get_plaintext_fields_with_encrypted(self):
     encrypted_fields = [EncryptedDeviceField('test_name', 'integer', 123),
                         EncryptedDeviceField('test2', 'string', 'something')]
     plaintext_fields = [DeviceField('test3', 'boolean', True), DeviceField('test4', 'string', 'something else')]
     device = Device('test', plaintext_fields, encrypted_fields, 'type')
     self.assertDictEqual(device.get_plaintext_fields(), {'test3': True, 'test4': 'something else'})
コード例 #21
0
 def test_get_plaintext_fields_plaintext_only(self):
     fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
     device = Device('test', fields, [], 'type')
     self.assertDictEqual(device.get_plaintext_fields(), {'test_name': 123, 'test2': 'something'})
コード例 #22
0
 def test_get_plaintext_fields_no_fields(self):
     device = Device('test', [], [], 'type')
     self.assertDictEqual(device.get_plaintext_fields(), {})
コード例 #23
0
 def test_init_with_both_plaintext_and_encrypted(self):
     plaintext_fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
     encrypted_fields = [EncryptedDeviceField('test3', 'boolean', True),
                         EncryptedDeviceField('test4', 'string', 'something else')]
     device = Device('test', plaintext_fields, encrypted_fields, 'type')
     self.assertConstructionIsCorrect(device, 'test', plaintext_fields, encrypted_fields, 'type')
コード例 #24
0
 def test_init_with_encrypted(self):
     fields = [EncryptedDeviceField('test_name', 'integer', 123),
               EncryptedDeviceField('test2', 'string', 'something')]
     device = Device('test', [], fields, 'type')
     self.assertConstructionIsCorrect(device, 'test', [], fields, 'type')
コード例 #25
0
ファイル: test_app_base.py プロジェクト: xa7YvcR3/WALKOFF
class TestAppBase(TestCase):
    def setUp(self):
        self.test_app_name = 'TestApp'
        self.device1 = Device('test', [], [], 'type1')
        plaintext_fields = [
            DeviceField('test_name', 'integer', 123),
            DeviceField('test2', 'string', 'something')
        ]
        encrypted_fields = [
            EncryptedDeviceField('test3', 'boolean', True),
            EncryptedDeviceField('test4', 'string', 'something else')
        ]
        self.device2 = Device('test2', plaintext_fields, encrypted_fields,
                              'type2')
        self.db_app = App(name=self.test_app_name,
                          devices=[self.device1, self.device2])

        device_db.session.add(self.db_app)
        device_db.session.commit()

    def tearDown(self):
        device_db.session.rollback()
        for device in device_db.session.query(Device).all():
            device_db.session.delete(device)
        for field in device_db.session.query(DeviceField).all():
            device_db.session.delete(field)
        for field in device_db.session.query(EncryptedDeviceField).all():
            device_db.session.delete(field)
        app = device_db.session.query(App).filter(
            App.name == self.test_app_name).first()
        if app is not None:
            device_db.session.delete(app)
        device_db.session.commit()

    def test_app_is_tagged(self):
        self.assertTrue(getattr(AppBase, '_is_walkoff_app', False))

    def test_init(self):
        app = AppBase(self.test_app_name, self.device1.id)
        self.assertEqual(app.app, self.db_app)
        self.assertEqual(app.device, self.device1)
        self.assertDictEqual(app.device_fields, {})
        self.assertEqual(app.device_type, 'type1')
        self.assertEqual(app.device_id, self.device1.id)

    def test_init_with_fields(self):
        app = AppBase(self.test_app_name, self.device2.id)
        self.assertEqual(app.app, self.db_app)
        self.assertEqual(app.device, self.device2)
        self.assertDictEqual(app.device_fields,
                             self.device2.get_plaintext_fields())
        self.assertEqual(app.device_type, 'type2')
        self.assertEqual(app.device_id, self.device2.id)

    def test_init_with_invalid_app(self):
        app = AppBase('Invalid', self.device2.id)
        self.assertIsNone(app.app)
        self.assertIsNone(app.device)
        self.assertDictEqual(app.device_fields, {})
        self.assertEqual(app.device_type, None)
        self.assertEqual(app.device_id, self.device2.id)

    def test_init_with_invalid_device(self):
        app = AppBase(self.test_app_name, 'invalid')
        self.assertEqual(app.app, self.db_app)
        self.assertIsNone(app.device)
        self.assertDictEqual(app.device_fields, {})
        self.assertEqual(app.device_type, None)
        self.assertEqual(app.device_id, 'invalid')

    def test_get_all_devices(self):
        app = AppBase(self.test_app_name, self.device2.id)
        devices = app.get_all_devices()
        self.assertIn(self.device1, devices)
        self.assertIn(self.device2, devices)

    def test_get_all_devices_invalid_app(self):
        app = AppBase('Invalid', self.device2.id)
        self.assertListEqual(app.get_all_devices(), [])
コード例 #26
0
 def test_get_encrypted_field(self):
     fields = [EncryptedDeviceField('test_name', 'integer', 123),
               EncryptedDeviceField('test2', 'string', 'something')]
     device = Device('test', [], fields, 'type')
     self.assertEqual(device.get_encrypted_field('test_name'), 123)
コード例 #27
0
 def test_get_encrypted_field_dne(self):
     fields = [EncryptedDeviceField('test_name', 'integer', 123),
               EncryptedDeviceField('test2', 'string', 'something')]
     device = Device('test', [], fields, 'type')
     with self.assertRaises(UnknownDeviceField):
         device.get_encrypted_field('invalid')
コード例 #28
0
 def test_init_with_description(self):
     device = Device('test', [], [], 'type', description='desc')
     self.assertConstructionIsCorrect(device, 'test', [], [], 'type', description='desc')
コード例 #29
0
 def test_init_name_only(self):
     device = Device('test', [], [], 'type')
     self.assertConstructionIsCorrect(device, 'test', [], [], 'type')
コード例 #30
0
 def test_init_with_plaintext(self):
     fields = [DeviceField('test_name', 'integer', 123), DeviceField('test2', 'string', 'something')]
     device = Device('test', fields, [], 'type')
     self.assertConstructionIsCorrect(device, 'test', fields, [], 'type')