Merge "Move python files to root dir"

1 files changed, 355 insertions, 0 deletions

diff --git a/nfvparser/toscaparser/tests/test_scalarunit.py b/nfvparser/toscaparser/tests/test_scalarunit.py
new file mode 100644
index 0000000..09a24b6
--- /dev/null
+++ b/nfvparser/toscaparser/tests/test_scalarunit.py
@@ -0,0 +1,355 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.common import exception
+from toscaparser.elements.scalarunit import ScalarUnit_Frequency
+from toscaparser.elements.scalarunit import ScalarUnit_Size
+from toscaparser.elements.scalarunit import ScalarUnit_Time
+from toscaparser.nodetemplate import NodeTemplate
+from toscaparser.tests.base import TestCase
+from toscaparser.utils.gettextutils import _
+from toscaparser.utils import yamlparser
+
+
+class ScalarUnitPositiveTest(TestCase):
+
+    scenarios = [
+        (
+            # tpl_snippet with mem_size given as number+space+MB
+            'mem_size_is_number_Space_MB',
+            dict(tpl_snippet='''
+                 server:
+                   type: tosca.nodes.Compute
+                   capabilities:
+                     host:
+                       properties:
+                         mem_size: 1024 MB
+                 ''',
+                 property='mem_size',
+                 expected='1024 MB')
+        ),
+        (
+            # tpl_snippet with mem_size given as number+spaces+GB
+            'mem_size_is_number_Space_GB',
+            dict(tpl_snippet='''
+                 server:
+                   type: tosca.nodes.Compute
+                   capabilities:
+                     host:
+                       properties:
+                         mem_size: 1     GB
+                 ''',
+                 property='mem_size',
+                 expected='1 GB')
+        ),
+        (
+            # tpl_snippet with mem_size given as number+tiB
+            'mem_size_is_number_NoSpace_GB',
+            dict(tpl_snippet='''
+                 server:
+                   type: tosca.nodes.Compute
+                   capabilities:
+                     host:
+                       properties:
+                         mem_size: 1tiB
+                 ''',
+                 property='mem_size',
+                 expected='1 TiB')
+        ),
+        (
+            # tpl_snippet with mem_size given as number+Spaces+GIB
+            'mem_size_is_number_Spaces_GB',
+            dict(tpl_snippet='''
+                 server:
+                   type: tosca.nodes.Compute
+                   capabilities:
+                     host:
+                       properties:
+                         mem_size: 1     GIB
+                 ''',
+                 property='mem_size',
+                 expected='1 GiB')
+        ),
+        (
+            # tpl_snippet with mem_size given as number+Space+tib
+            'mem_size_is_number_Spaces_GB',
+            dict(tpl_snippet='''
+                 server:
+                   type: tosca.nodes.Compute
+                   capabilities:
+                     host:
+                       properties:
+                         mem_size: 1 tib
+                 ''',
+                 property='mem_size',
+                 expected='1 TiB')
+        ),
+        (
+            'cpu_frequency_is_float_Space_GHz',
+            dict(tpl_snippet='''
+                 server:
+                   type: tosca.nodes.Compute
+                   capabilities:
+                     host:
+                       properties:
+                         cpu_frequency: 2.5 GHz
+                 ''',
+                 property='cpu_frequency',
+                 expected='2.5 GHz')
+        ),
+        (
+            'cpu_frequency_is_float_Space_MHz',
+            dict(tpl_snippet='''
+                 server:
+                   type: tosca.nodes.Compute
+                   capabilities:
+                     host:
+                       properties:
+                         cpu_frequency: 800 MHz
+                 ''',
+                 property='cpu_frequency',
+                 expected='800 MHz')
+        ),
+    ]
+
+    def test_scenario_scalar_unit_positive(self):
+        tpl = self.tpl_snippet
+        nodetemplates = yamlparser.simple_parse(tpl)
+        nodetemplate = NodeTemplate('server', nodetemplates)
+        props = nodetemplate.get_capability('host').get_properties()
+        prop_name = self.property
+        if props and prop_name in props.keys():
+            prop = props[prop_name]
+            self.assertIsNone(prop.validate())
+            resolved = prop.value
+        self.assertEqual(resolved, self.expected)
+
+
+class GetNumFromScalarUnitSizePositive(TestCase):
+
+    scenarios = [
+        (   # Note that (1 TB) / (1 GB) = 1000
+            'Input is TB, user input is GB',
+            dict(InputMemSize='1   TB',
+                 UserInputUnit='gB',
+                 expected=1000)
+        ),
+        (   # Note that (1 Tib)/ (1 GB) = 1099
+            'Input is TiB, user input is GB',
+            dict(InputMemSize='1   TiB',
+                 UserInputUnit='gB',
+                 expected=1099.511627776)
+        ),
+    ]
+
+    def test_scenario_get_num_from_scalar_unit_size(self):
+        resolved = (ScalarUnit_Size(self.InputMemSize).
+                    get_num_from_scalar_unit(self.UserInputUnit))
+        self.assertEqual(resolved, self.expected)
+
+
+class GetNumFromScalarUnitFrequencyPositive(TestCase):
+
+    scenarios = [
+        (   # Note that (1 GHz) / (1 Hz) = 1000000000
+            'Input is GHz, user input is Hz',
+            dict(InputMemSize='1   GHz',
+                 UserInputUnit='Hz',
+                 expected=1000000000)
+        ),
+        (
+            'Input is GHz, user input is Hz',
+            dict(InputMemSize='2.4   GHz',
+                 UserInputUnit='Hz',
+                 expected=2400000000)
+        ),
+        (   # Note that (1 GHz)/ (1 MHz) = 1000
+            'Input is MHz, user input is GHz',
+            dict(InputMemSize='800   MHz',
+                 UserInputUnit='GHz',
+                 expected=0.8)
+        ),
+        (
+            'Input is GHz, user input is Hz',
+            dict(InputMemSize='0.9  GHz',
+                 UserInputUnit='MHz',
+                 expected=900)
+        ),
+        (
+            'Input is GHz, user input is Hz',
+            dict(InputMemSize='2.7GHz',
+                 UserInputUnit='MHz',
+                 expected=2700)
+        ),
+    ]
+
+    def test_scenario_get_num_from_scalar_unit_frequency(self):
+        resolved = (ScalarUnit_Frequency(self.InputMemSize).
+                    get_num_from_scalar_unit(self.UserInputUnit))
+        self.assertEqual(resolved, self.expected)
+
+
+class GetNumFromScalarUnitTimePositive(TestCase):
+
+    scenarios = [
+        (   # Note that (1 s) / (1 ms) = 1000
+            'Input is 500ms, user input is s',
+            dict(InputMemSize='500   ms',
+                 UserInputUnit='s',
+                 expected=0.5)
+        ),
+        (   # Note that (1 h)/ (1 s) = 3600
+            'Input is h, user input is s',
+            dict(InputMemSize='1   h',
+                 UserInputUnit='s',
+                 expected=3600)
+        ),
+        (   # Note that (1 m)/ (1 s) = 60
+            'Input is m, user input is s',
+            dict(InputMemSize='0.5   m',
+                 UserInputUnit='s',
+                 expected=30)
+        ),
+        (   # Note that (1 d)/ (1 h) = 24
+            'Input is d, user input is h',
+            dict(InputMemSize='1   d',
+                 UserInputUnit='h',
+                 expected=24)
+        ),
+    ]
+
+    def test_scenario_get_num_from_scalar_unit_time(self):
+        resolved = (ScalarUnit_Time(self.InputMemSize).
+                    get_num_from_scalar_unit(self.UserInputUnit))
+        self.assertEqual(resolved, self.expected)
+
+
+class GetNumFromScalarUnitSizeNegative(TestCase):
+
+    InputMemSize = '1 GB'
+    UserInputUnit = 'qB'
+
+    def test_get_num_from_scalar_unit_size_negative(self):
+        try:
+            (ScalarUnit_Size(self.InputMemSize).
+             get_num_from_scalar_unit(self.UserInputUnit))
+        except Exception as error:
+            self.assertIsInstance(error, ValueError)
+            self.assertEqual(_('The unit "qB" is not valid. Valid units are '
+                               '"[\'B\', \'GB\', \'GiB\', \'KiB\', \'MB\', '
+                               '\'MiB\', \'TB\', \'TiB\', \'kB\']".'),
+                             error.__str__())
+
+
+class GetNumFromScalarUnitFrequencyNegative(TestCase):
+
+    InputFrequency = '2.7 GHz'
+    UserInputUnit = 'Jz'
+
+    def test_get_num_from_scalar_unit_frequency_negative(self):
+        try:
+            (ScalarUnit_Frequency(self.InputFrequency).
+             get_num_from_scalar_unit(self.UserInputUnit))
+        except Exception as error:
+            self.assertIsInstance(error, ValueError)
+            self.assertEqual(_('The unit "Jz" is not valid. Valid units are '
+                               '"[\'GHz\', \'Hz\', \'MHz\', \'kHz\']".'),
+                             error.__str__())
+
+
+class GetNumFromScalarUnitTimeNegative(TestCase):
+
+    InputTime = '5 ms'
+    UserInputUnit = 'D'
+
+    def test_get_num_from_scalar_unit_frequency_negative(self):
+        try:
+            (ScalarUnit_Time(self.InputTime).
+             get_num_from_scalar_unit(self.UserInputUnit))
+        except Exception as error:
+            self.assertIsInstance(error, ValueError)
+            self.assertEqual(_('"Jz" is not a valid scalar-unit.'),
+                             error.__str__())
+
+
+class ScalarUnitNegativeTest(TestCase):
+
+    custom_def_snippet = '''
+    tosca.my.nodes.Compute:
+      derived_from: tosca.nodes.Root
+      properties:
+        cpu_frequency:
+          required: false
+          type: scalar-unit.frequency
+          constraints:
+            - greater_or_equal: 0.1 GHz
+        disk_size:
+          required: false
+          type: scalar-unit.size
+          constraints:
+            - greater_or_equal: 1 GB
+        mem_size:
+          required: false
+          type: scalar-unit.size
+          constraints:
+            - in_range: [1 MiB, 1 GiB]
+    '''
+    custom_def = yamlparser.simple_parse(custom_def_snippet)
+
+    # disk_size doesn't provide a value, mem_size uses an invalid unit.
+    def test_invalid_scalar_unit(self):
+        tpl_snippet = '''
+        server:
+          type: tosca.my.nodes.Compute
+          properties:
+            cpu_frequency: 50.3.6 GHZ
+            disk_size: MB
+            mem_size: 1 QB
+        '''
+        nodetemplates = yamlparser.simple_parse(tpl_snippet)
+        nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
+        for p in nodetemplate.get_properties_objects():
+            self.assertRaises(ValueError, p.validate)
+
+    # disk_size is less than 1 GB, mem_size is not in the required range.
+    # Note: in the spec, the minimum value of mem_size is 1 MiB (> 1 MB)
+    def test_constraint_for_scalar_unit(self):
+        tpl_snippet = '''
+        server:
+          type: tosca.my.nodes.Compute
+          properties:
+            cpu_frequency: 0.05 GHz
+            disk_size: 500 MB
+            mem_size: 1 MB
+        '''
+        nodetemplates = yamlparser.simple_parse(tpl_snippet)
+        nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
+        props = nodetemplate.get_properties()
+        if 'cpu_frequency' in props.keys():
+            error = self.assertRaises(exception.ValidationError,
+                                      props['cpu_frequency'].validate)
+            self.assertEqual(_('The value "0.05 GHz" of property '
+                               '"cpu_frequency" must be greater than or equal '
+                               'to "0.1 GHz".'), error.__str__())
+        if 'disk_size' in props.keys():
+            error = self.assertRaises(exception.ValidationError,
+                                      props['disk_size'].validate)
+            self.assertEqual(_('The value "500 MB" of property "disk_size" '
+                               'must be greater than or equal to "1 GB".'),
+                             error.__str__())
+
+        if 'mem_size' in props.keys():
+            error = self.assertRaises(exception.ValidationError,
+                                      props['mem_size'].validate)
+            self.assertEqual(_('The value "1 MB" of property "mem_size" is '
+                               'out of range "(min:1 MiB, max:1 GiB)".'),
+                             error.__str__())