Release v1.0.0

tests/fields/test_AbstractField.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# type: ignore
+from __future__ import annotations
+
+import pytest
+from pytest_mock import MockerFixture
+
+from keep_it_secret import fields
+from keep_it_secret.secrets import Secrets
+
+
+def test_init():
+    # When
+    _ = fields.AbstractField()
+
+    # Then
+    assert True  # Nothing to test here ;)
+
+
+def test_init_with_field_options():
+    # When
+    result = fields.AbstractField(
+        as_type=int, required=False, description='spameggs',
+    )
+
+    # Then
+    assert result.as_type == int
+    assert result.required is False
+    assert result.description == 'spameggs'
+
+
+def test_new(mocker: MockerFixture):
+    # Given
+    mock_init = mocker.patch.object(
+        fields.AbstractField, '__init__', return_value=None,
+    )
+
+    # When
+    _ = fields.AbstractField.new(
+        as_type=int,
+        required=False,
+        description='spameggs',
+    )
+
+    # Then
+    mock_init.assert_called_once_with(
+        as_type=int,
+        required=False,
+        description='spameggs',
+    )
+
+
+def test_get_value(testing_secrets: Secrets):
+    # Given
+    field = fields.AbstractField()
+
+    with pytest.raises(NotImplementedError) as exception_info:
+        # When
+        _ = field.get_value(testing_secrets)
+
+    # Then
+    assert field.name in exception_info.value.args[0]

tests/fields/test_EnvField.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+# type: ignore
+from __future__ import annotations
+
+import pytest
+from pytest_mock import MockerFixture
+
+from keep_it_secret import fields
+from keep_it_secret.secrets import Secrets
+
+
+def test_init():
+    # When
+    result = fields.EnvField('KEEP_IT_SECRET_TESTS_SPAM')
+
+    # Then
+    assert result.key == 'KEEP_IT_SECRET_TESTS_SPAM'
+    assert result.default is None
+
+
+def test_init_with_default():
+    # When
+    result = fields.EnvField('KEEP_IT_SECRET_TESTS_SPAM', default='eggs')
+
+    # Then
+    assert result.default == 'eggs'
+
+
+def test_init_with_field_options():
+    # When
+    result = fields.EnvField(
+        'KEEP_IT_SECRET_TESTS_SPAM',
+        as_type=int,
+        required=False,
+        description='spameggs',
+    )
+
+    # Then
+    assert result.as_type == int
+    assert result.required is False
+    assert result.description == 'spameggs'
+
+
+def test_new(mocker: MockerFixture):
+    # Given
+    mock_init = mocker.patch.object(
+        fields.EnvField, '__init__', return_value=None,
+    )
+
+    # When
+    _ = fields.EnvField.new(
+        'KEEP_IT_SECRET_TESTS_SPAM',
+        default='eggs',
+        as_type=int,
+        required=False,
+        description='spameggs',
+    )
+
+    # Then
+    mock_init.assert_called_once_with(
+        'KEEP_IT_SECRET_TESTS_SPAM',
+        default='eggs',
+        as_type=int,
+        required=False,
+        description='spameggs',
+    )
+
+
+def test_get_value(testing_secrets: Secrets):
+    # Given
+    field = fields.EnvField('KEEP_IT_SECRET_TESTS_SPAM')
+
+    # When
+    result = field.get_value(testing_secrets)
+
+    # Then
+    assert result == 'spam'
+
+
+def test_get_value_required_value_missing(testing_secrets: Secrets):
+    # Given
+    field = fields.EnvField('KEEP_IT_SECRET_TESTS_IDONTEXIST', default=None)
+
+    with pytest.raises(field.RequiredValueMissing) as exception_info:
+        # When
+        _ = field.get_value(testing_secrets)
+
+    # Then
+    assert exception_info.value.args[0] == 'KEEP_IT_SECRET_TESTS_IDONTEXIST'
+
+
+def test_get_value_missing_not_required(testing_secrets: Secrets):
+    # Given
+    field = fields.EnvField('KEEP_IT_SECRET_TESTS_IDONTEXIST', required=False)
+
+    # When
+    result = field.get_value(testing_secrets)
+
+    # Then
+    assert result == field.default

tests/fields/test_Field.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+# type: ignore
+from __future__ import annotations
+
+import pytest
+from pytest_mock import MockerFixture
+
+from keep_it_secret import fields
+from keep_it_secret.secrets import Secrets
+
+
+class TestingField(fields.Field):
+    def get_value(self, secrets):
+        return 'test'
+
+
+def test_init():
+    # When
+    result = TestingField()
+
+    # Then
+    assert result.as_type == str
+    assert result.required is True
+    assert result.description is None
+    assert isinstance(result.name, str) is True
+    assert len(result.name) > 0
+
+
+def test_new(mocker: MockerFixture):
+    # Given
+    mock_init = mocker.patch.object(
+        TestingField, '__init__', return_value=None,
+    )
+
+    # When
+    _ = TestingField.new(
+        as_type=int,
+        required=False,
+        description='spameggs',
+    )
+
+    # Then
+    mock_init.assert_called_once_with(
+        as_type=int,
+        required=False,
+        description='spameggs',
+    )
+
+
+@pytest.mark.parametrize(
+    'argument,value',
+    [
+        ('as_type', int),
+        ('required', False),
+        ('description', 'spam'),
+    ],
+)
+def test_init_with_kwargs(argument, value):
+    # When
+    result = TestingField(**{argument: value})
+
+    # Then
+    assert getattr(result, argument) == value
+
+
+def test_call(mocker: MockerFixture, testing_secrets: Secrets):
+    # Given
+    field = TestingField()
+
+    # When
+    result = field(testing_secrets)
+
+    # Then
+    assert result == 'test'
+
+
+def test_call_get_value_call(mocker: MockerFixture, testing_secrets: Secrets):
+    # Given
+    field = TestingField()
+
+    mock_get_value = mocker.patch.object(
+        field, 'get_value', return_value='spam',
+    )
+
+    # When
+    result = field(testing_secrets)
+
+    # Then
+    assert result == 'spam'
+
+    mock_get_value.assert_called_once_with(testing_secrets)
+
+
+def test_call_get_value_None(mocker: MockerFixture, testing_secrets: Secrets):
+    # Given
+    field = TestingField(as_type=int)
+
+    _ = mocker.patch.object(field, 'get_value', return_value=None)
+
+    # When
+    result = field(testing_secrets)
+
+    # Then
+    assert result is None
+
+
+def test_call_with_as_type(mocker: MockerFixture, testing_secrets: Secrets):
+    # Given
+    field = TestingField(as_type=int)
+
+    _ = mocker.patch.object(field, 'get_value', return_value='5')
+
+    # When
+    result = field(testing_secrets)
+
+    # Then
+    assert result == 5

tests/fields/test_LiteralField.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+# type: ignore
+from __future__ import annotations
+
+from pytest_mock import MockerFixture
+
+from keep_it_secret import fields
+from keep_it_secret.secrets import Secrets
+
+
+def test_init():
+    # When
+    result = fields.LiteralField('spam')
+
+    # Then
+    assert result.as_type is None
+    assert result.value == 'spam'
+
+
+def test_init_with_field_options():
+    # When
+    result = fields.LiteralField(
+        'spam', as_type=int, required=False, description='eggs',
+    )
+
+    # Then
+    assert result.as_type is None
+    assert result.required is False
+    assert result.description == 'eggs'
+
+
+def test_new(mocker: MockerFixture):
+    # Given
+    mock_init = mocker.patch.object(
+        fields.LiteralField, '__init__', return_value=None,
+    )
+
+    # When
+    _ = fields.LiteralField.new(
+        'spam', as_type=int, required=False, description='eggs',
+    )
+
+    # Then
+    mock_init.assert_called_once_with(
+        'spam', as_type=int, required=False, description='eggs',
+    )
+
+
+def test_get_value(testing_secrets: Secrets):
+    # Given
+    field = fields.LiteralField('spam')
+
+    # When
+    result = field.get_value(testing_secrets)
+
+    # Then
+    assert result == 'spam'

tests/fields/test_SecretsField.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+# type: ignore
+from __future__ import annotations
+
+from unittest import mock
+
+from pytest_mock import MockerFixture
+
+from keep_it_secret import fields
+from keep_it_secret.secrets import Secrets
+
+
+def test_init():
+    # When
+    result = fields.SecretsField(Secrets)
+
+    # Then
+    assert result.as_type is None
+    assert result.klass == Secrets
+
+
+def test_init_with_field_options():
+    # When
+    result = fields.SecretsField(
+        Secrets, as_type=int, required=False, description='eggs',
+    )
+
+    # Then
+    assert result.as_type is None
+    assert result.required is False
+    assert result.description == 'eggs'
+
+
+def test_new(mocker: MockerFixture):
+    # Given
+    mock_init = mocker.patch.object(
+        fields.SecretsField, '__init__', return_value=None,
+    )
+
+    # When
+    _ = fields.SecretsField.new(
+        Secrets, as_type=int, required=False, description='eggs',
+    )
+
+    # Then
+    mock_init.assert_called_once_with(
+        Secrets, as_type=int, required=False, description='eggs',
+    )
+
+
+def test_get_value(testing_secrets: Secrets):
+    # Given
+    wrapped_secrets = mock.Mock(spec=Secrets)
+    mock_secrets_class = mock.Mock(return_value=wrapped_secrets)
+
+    field = fields.SecretsField(mock_secrets_class)
+
+    # When
+    result = field.get_value(testing_secrets)
+
+    # Then
+    assert result == wrapped_secrets
+
+    mock_secrets_class.assert_called_once_with(parent=testing_secrets)