Develop 2016 0509 0030 (#33111)

* Disallow negative value for fib number

Fibonacci number is supposed to be nonnegative. Add this new feature to
disallow negative value to be passed in for fib number.

* Minimize code duplication

* Use /etc/adjtime for Gentoo

* Add integration test for timezone module

salt/modules/test.py

@@ -321,6 +321,8 @@ def fib(num):
         salt '*' test.fib 3
     '''
     num = int(num)
+    if num < 0:
+        raise ValueError('Negative number is not allowed!')
     start = time.time()
     if num < 2:
         return num, time.time() - start

salt/modules/timezone.py

@@ -314,7 +314,7 @@ def get_hwclock():
 
     else:
         os_family = __grains__['os_family']
-        for family in ('RedHat', 'Suse'):
+        for family in ('RedHat', 'Suse', 'Gentoo'):
             if family in os_family:
                 cmd = ['tail', '-n', '1', '/etc/adjtime']
                 return __salt__['cmd.run'](cmd, python_shell=False)
@@ -336,24 +336,6 @@ def get_hwclock():
             # Since Wheezy
             cmd = ['tail', '-n', '1', '/etc/adjtime']
             return __salt__['cmd.run'](cmd, python_shell=False)
-        elif 'Gentoo' in __grains__['os_family']:
-            offset_file = '/etc/conf.d/hwclock'
-            try:
-                with salt.utils.fopen(offset_file, 'r') as fp_:
-                    for line in fp_:
-                        if line.startswith('clock='):
-                            line = line.rstrip('\n')
-                            return line.split('=')[-1].strip('\'"')
-                    raise CommandExecutionError(
-                        'Offset information not found in {0}'.format(
-                            offset_file
-                        )
-                    )
-            except IOError as exc:
-                raise CommandExecutionError(
-                    'Problem reading offset file {0}: {1}'
-                    .format(offset_file, exc.strerror)
-                )
         elif 'Solaris' in __grains__['os_family']:
             offset_file = '/etc/rtc_config'
             try:

tests/integration/modules/timezone.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+'''
+Integration tests for timezone module
+
+Only Linux is supported for the mement
+'''
+
+# Import python libs
+from __future__ import absolute_import
+
+# Import Salt Testing libs
+from salttesting.helpers import ensure_in_syspath
+ensure_in_syspath('../../')
+
+# Import salt libs
+import integration
+
+
+class TimezoneModuleTest(integration.ModuleCase):
+    def setUp(self):
+        '''
+        Set up Linux test environment
+        '''
+        ret_grain = self.run_function('grains.item', ['kernel'])
+        if 'Linux' not in ret_grain['kernel']:
+            self.skipTest('For Linux only')
+        super(TimezoneModuleTest, self).setUp()
+
+    def test_get_hwclock(self):
+        timezone = ['UTC', 'localtime']
+        ret = self.run_function('timezone.get_hwclock')
+        self.assertIn(ret, timezone)
+
+
+if __name__ == '__main__':
+    from integration import run_tests
+    run_tests(TimezoneModuleTest)

tests/integration/states/cmd.py

@@ -40,134 +40,125 @@ class CMDTest(integration.ModuleCase,
                              cwd=tempfile.gettempdir(), test=True)
         self.assertSaltNoneReturn(ret)
 
-    def test_run_redirect(self):
-        '''
-        test cmd.run with shell redirect
-        '''
-        state_name = 'run_redirect'
-        state_filename = state_name + '.sls'
-        state_file = os.path.join(STATE_DIR, state_filename)
 
-        date_file = tempfile.mkstemp()[1]
-        state_key = 'cmd_|-date > {0}_|-date > {0}_|-run'.format(date_file)
-        try:
-            salt.utils.fopen(state_file, 'w').write(textwrap.dedent('''\
-                date > {0}:
-                  cmd.run
-                '''.format(date_file)))
+class CMDRunRedirectTest(integration.ModuleCase,
+                         integration.SaltReturnAssertsMixIn):
+    '''
+    Validate the cmd state of run_redirect
+    '''
+    def setUp(self):
+        self.state_name = 'run_redirect'
+        state_filename = self.state_name + '.sls'
+        self.state_file = os.path.join(STATE_DIR, state_filename)
+        self.test_file = tempfile.mkstemp()[1]
+        super(CMDRunRedirectTest, self).setUp()
 
-            ret = self.run_function('state.sls', [state_name])
-            self.assertTrue(ret[state_key]['result'])
-        finally:
-            os.remove(state_file)
-            os.remove(date_file)
+    def tearDown(self):
+        os.remove(self.state_file)
+        os.remove(self.test_file)
+        super(CMDRunRedirectTest, self).tearDown()
 
     def test_run_unless(self):
         '''
         test cmd.run unless
         '''
-        state_name = 'run_redirect'
-        state_filename = state_name + '.sls'
-        state_file = os.path.join(STATE_DIR, state_filename)
-
-        unless_file = tempfile.mkstemp()[1]
         state_key = 'cmd_|-/var/log/messages_|-/var/log/messages_|-run'
-        try:
-            salt.utils.fopen(state_file, 'w').write(textwrap.dedent('''\
-                /var/log/messages:
-                  cmd.run:
-                    - unless: echo cheese > {0}
-                '''.format(unless_file)))
+        salt.utils.fopen(self.state_file, 'w').write(textwrap.dedent('''\
+            /var/log/messages:
+              cmd.run:
+                - unless: echo cheese > {0}
+            '''.format(self.test_file)))
 
-            ret = self.run_function('state.sls', [state_name])
-            self.assertTrue(ret[state_key]['result'])
-        finally:
-            os.remove(state_file)
-            os.remove(unless_file)
+        ret = self.run_function('state.sls', [self.state_name])
+        self.assertTrue(ret[state_key]['result'])
 
     def test_run_creates_exists(self):
         '''
         test cmd.run creates already there
         '''
-        state_name = 'run_redirect'
-        state_filename = state_name + '.sls'
-        state_file = os.path.join(STATE_DIR, state_filename)
+        state_key = 'cmd_|-touch {0}_|-touch {0}_|-run'.format(self.test_file)
+        salt.utils.fopen(self.state_file, 'w').write(textwrap.dedent('''\
+            touch {0}:
+              cmd.run:
+                - creates: {0}
+            '''.format(self.test_file)))
 
-        creates_file = tempfile.mkstemp()[1]
-        state_key = 'cmd_|-touch {0}_|-touch {0}_|-run'.format(creates_file)
-        try:
-            salt.utils.fopen(state_file, 'w').write(textwrap.dedent('''\
-                touch {0}:
-                  cmd.run:
-                    - creates: {0}
-                '''.format(creates_file)))
-
-            ret = self.run_function('state.sls', [state_name])
-            self.assertTrue(ret[state_key]['result'])
-            self.assertEqual(len(ret[state_key]['changes']), 0)
-        finally:
-            os.remove(state_file)
-            os.remove(creates_file)
+        ret = self.run_function('state.sls', [self.state_name])
+        self.assertTrue(ret[state_key]['result'])
+        self.assertEqual(len(ret[state_key]['changes']), 0)
 
     def test_run_creates_new(self):
         '''
         test cmd.run creates not there
         '''
-        state_name = 'run_redirect'
-        state_filename = state_name + '.sls'
-        state_file = os.path.join(STATE_DIR, state_filename)
+        os.remove(self.test_file)
+        state_key = 'cmd_|-touch {0}_|-touch {0}_|-run'.format(self.test_file)
+        salt.utils.fopen(self.state_file, 'w').write(textwrap.dedent('''\
+            touch {0}:
+              cmd.run:
+                - creates: {0}
+            '''.format(self.test_file)))
 
-        creates_file = tempfile.mkstemp()[1]
-        os.remove(creates_file)
-        state_key = 'cmd_|-touch {0}_|-touch {0}_|-run'.format(creates_file)
-        try:
-            salt.utils.fopen(state_file, 'w').write(textwrap.dedent('''\
-                touch {0}:
-                  cmd.run:
-                    - creates: {0}
-                '''.format(creates_file)))
+        ret = self.run_function('state.sls', [self.state_name])
+        self.assertTrue(ret[state_key]['result'])
+        self.assertEqual(len(ret[state_key]['changes']), 4)
 
-            ret = self.run_function('state.sls', [state_name])
-            self.assertTrue(ret[state_key]['result'])
-            self.assertEqual(len(ret[state_key]['changes']), 4)
-        finally:
-            os.remove(state_file)
-            os.remove(creates_file)
+    def test_run_redirect(self):
+        '''
+        test cmd.run with shell redirect
+        '''
+        state_key = 'cmd_|-date > {0}_|-date > {0}_|-run'.format(self.test_file)
+        salt.utils.fopen(self.state_file, 'w').write(textwrap.dedent('''\
+            date > {0}:
+              cmd.run
+            '''.format(self.test_file)))
+
+        ret = self.run_function('state.sls', [self.state_name])
+        self.assertTrue(ret[state_key]['result'])
+
+
+class CMDRunWatchTest(integration.ModuleCase,
+                      integration.SaltReturnAssertsMixIn):
+    '''
+    Validate the cmd state of run_watch
+    '''
+    def setUp(self):
+        self.state_name = 'run_watch'
+        state_filename = self.state_name + '.sls'
+        self.state_file = os.path.join(STATE_DIR, state_filename)
+        super(CMDRunWatchTest, self).setUp()
+
+    def tearDown(self):
+        os.remove(self.state_file)
+        super(CMDRunWatchTest, self).tearDown()
 
     def test_run_watch(self):
         '''
         test cmd.run watch
         '''
-        state_name = 'run_watch'
-        state_filename = state_name + '.sls'
-        state_file = os.path.join(STATE_DIR, state_filename)
-
         saltines_key = 'cmd_|-saltines_|-echo_|-run'
         biscuits_key = 'cmd_|-biscuits_|-echo hello_|-wait'
 
-        try:
-            salt.utils.fopen(state_file, 'w').write(textwrap.dedent('''\
-                saltines:
-                  cmd.run:
-                    - name: echo
-                    - cwd: /
-                    - stateful: True
+        salt.utils.fopen(self.state_file, 'w').write(textwrap.dedent('''\
+            saltines:
+              cmd.run:
+                - name: echo
+                - cwd: /
+                - stateful: True
 
-                biscuits:
-                  cmd.wait:
-                    - name: echo hello
-                    - cwd: /
-                    - watch:
-                        - cmd: saltines
-                '''))
+            biscuits:
+              cmd.wait:
+                - name: echo hello
+                - cwd: /
+                - watch:
+                    - cmd: saltines
+            '''))
 
-            ret = self.run_function('state.sls', [state_name])
-            self.assertTrue(ret[saltines_key]['result'])
-            self.assertTrue(ret[biscuits_key]['result'])
-        finally:
-            os.remove(state_file)
+        ret = self.run_function('state.sls', [self.state_name])
+        self.assertTrue(ret[saltines_key]['result'])
+        self.assertTrue(ret[biscuits_key]['result'])
 
 
 if __name__ == '__main__':
     from integration import run_tests
-    run_tests(CMDTest)
+    run_tests([CMDTest, CMDRunRedirectTest, CMDRunWatchTest])