#!/usr/bin/env python

'''
    As is tests for installApp.py prior to refactoring,

    just going for characterization, not completeness
'''

import unittest
import os
from mock import Mock

# fake the DM, since it doesn't exist in repo land
# taken from http://code.activestate.com/recipes/82234-importing-a
# -dynamically-generated-module/
import sys
import imp


def make_fake_module(name):
    module = imp.new_module(name)
    exec '' in module.__dict__
    sys.modules[name] = module
    return module

# now add the mocks we need to the dm
devicemanagerSUT = make_fake_module('devicemanagerSUT')

# the_mock is the instance of DeviceManagerSUT class that will be
# instantiated. By setting it as the return value, no other mocking is
# done in the DeviceManagerSUT class.
the_mock = Mock()
devicemanagerSUT.DeviceManagerSUT = Mock(return_value=the_mock)

# since sut_lib methods are imported directly, we'll create the fake
# module, then add mocks for the cited routines
sut_lib = make_fake_module('sut_lib')
sut_lib = Mock()

# And the mocks we need from sut_lib
import sut_lib
# the routines we import by name from sut_lib, each need their own
# mock, so they are present when installApp imports them by name
sut_lib.getOurIP = Mock()
sut_lib.calculatePort = Mock()
sut_lib.clearFlag = Mock()
sut_lib.setFlag = Mock()
sut_lib.checkDeviceRoot = Mock(return_value='/fake_root')
sut_lib.getDeviceTimestamp = Mock()
sut_lib.setDeviceTimestamp = Mock()
sut_lib.getResolution = Mock(return_value=[1024, 768])
sut_lib.waitForDevice = Mock()
sut_lib.runCommand = Mock()

import time

import installApp


class InstallAppTestCase(unittest.TestCase):
    def setUp(self):
        # every test should reset the counts
        the_mock.reset_mock()
        # we want to ensure a "success" from the installApp method
        the_mock.installApp.return_value = None
        # don't exercise find code by default
        os.path.exists = Mock(return_value=True)
        # we don't really want to wait during testing
        time.sleep = Mock()


class CheckBasicExecution(InstallAppTestCase):
    def setUp(self):
        super(CheckBasicExecution, self).setUp()
        os.environ['SUT_NAME'] = 'fred'

    def test_errors_no_args(self):
        # TypeError is a side effect of being run in
        # not-the-normal-foopy environment.
        self.assertRaises(TypeError, installApp.main)

    def test_error_short_args(self):
        # we expect the script to exit via sys.exit(1)
        try:
            # since a "normal" or "clean" script exits via sys.exit(0),
            # we need to catch the exception, and inspect the return
            # code (i.e.  we can't use the normal "assertRaises"
            # approach)
            installApp.main(['app', 1])
        except SystemExit as e:
            self.assertEqual(1, e.code)
        else:
            self.fail('should have exited via sys.exit(1)')

    def test_two_args_okay(self):
        installApp.main(['app', 1, '/path/to/source_file'])

    def test_three_args_okay(self):
        installApp.main(['app', 1, '/path/to/source_file', 3])


class CheckArguementHandling(InstallAppTestCase):
    # N.B. the 3rd arguement to installApp.py is never used, so can
    # not be tested

    def testIPAddress(self):
        for ip in ('hostname', '255.255.255.255'):
            installApp.main(['app', ip, 'path/to/something'])
            devicemanagerSUT.DeviceManagerSUT.assert_called_with(ip)

    def testSourceFileName(self):
        root_path = sut_lib.checkDeviceRoot()
        for source_file in ['test_1', 'test_2']:
            src_path = os.path.join('/path/to', source_file)
            installed_path = os.path.join(root_path, source_file)
            expected_args = ((installed_path,), {})
            installApp.main(['app', 1, src_path])
            self.assertTrue(
                expected_args in the_mock.installApp.call_args_list)


class CheckOriginalContract(InstallAppTestCase):
    def setUp(self):
        super(CheckOriginalContract, self).setUp()
        the_mock.reset_mock()

    # bummer expectedFailure decorator is not supported before py 2.7
    # unittest, so just disable the test
    # @unittest.expectedFailure
    def XXXtestOneSetOfCalls(self):
        root_path = sut_lib.checkDeviceRoot()
        source_file = 'testing'
        source_path = os.path.join('/path/to', source_file)
        installed_path = os.path.join(root_path, source_file)
        installApp.main(['app', 1, source_path])
        the_mock.pushFile.assert_called_once_with(source_path, installed_path)
        the_mock.installApp.assert_called_once_with(installed_path)


class CheckNewContract(InstallAppTestCase):

    def test_robocop_found(self):
        root_path = sut_lib.checkDeviceRoot()
        source_file = 'fennec.eggs.arm.apk'
        robocop_file = 'robocop.apk'
        source_path = os.path.join('build/', source_file)
        robocop_source_path = os.path.join('build/tests/bin', robocop_file)
        installed_path = os.path.join(root_path, source_file)
        robocop_installed_path = os.path.join(root_path, robocop_file)
        expected_pushFile_calls = [((source_path, installed_path), {}),
                                   ((robocop_source_path, robocop_installed_path), {})]
        expected_installApp_calls = [((installed_path,), {}),
                                     ((robocop_installed_path,), {})]

        installApp.main(['app', 1, source_path])

        self.assertEqual(the_mock.installApp.call_args_list,
                         expected_installApp_calls)
        self.assertEqual(the_mock.pushFile.call_args_list,
                         expected_pushFile_calls)

    def test_robocop_not_found(self):
        root_path = sut_lib.checkDeviceRoot()
        source_file = 'fennec.eggs.arm.apk'
        source_path = os.path.join('build/', source_file)
        installed_path = os.path.join(root_path, source_file)
        expected_pushFile_calls = [((source_path, installed_path), {}), ]
        expected_installApp_calls = [((installed_path,), {}), ]

        # simulate not finding robocop.apk - should not attempt install
        # then
        os.path.exists.return_value = False
        installApp.main(['app', 1, source_path])

        self.assertEqual(the_mock.installApp.call_args_list,
                         expected_installApp_calls)
        self.assertEqual(the_mock.pushFile.call_args_list,
                         expected_pushFile_calls)


class CheckRobocopFind(InstallAppTestCase):

    def test_null_path_if_not_found(self):
        os.path.exists.return_value = False
        found_path = installApp.find_robocop()
        self.assertFalse(found_path,
                         "Should not have found robocop.apk")

    def test_correct_path_if_found(self):
        os.path.exists.return_value = True
        found_path = installApp.find_robocop()
        self.assertTrue(found_path,
                        "Should have found robocop.apk")

if __name__ == '__main__':
    unittest.main()