def test_add_nested_folder(self):
        folder = '%s/%s/%s' % \
            (random_string(), random_string(), random_string())
        self.filestore.add_folder(folder)

        filepath = os.path.join(self.filepath, folder)
        self.assertTrue(os.path.exists(filepath))

 def test_load_file_failure(self, m_load, _):
     m_load.side_effect = ztpserver.serializers.SerializerError
     self.assertRaises(ztpserver.serializers.SerializerError,
                       load_file,
                       random_string(),
                       random_string(),
                       random_string())

    def test_match_failure(self):
        interface = random_string()
        remote_device = random_string()
        remote_interface = random_string()

        for intf in ['none', interface + 'dummy']:
            pattern = InterfacePattern(intf, remote_device, 
                                       remote_interface,
                                       random_string())
            neighbor = Neighbor(remote_device, remote_interface)
            result = pattern.match(interface, [neighbor])
            self.assertFalse(result)

        for remote_d in ['none', remote_device + 'dummy']:
            pattern = InterfacePattern(interface, remote_d, 
                                       remote_interface,
                                       random_string())
            neighbor = Neighbor(remote_device, remote_interface)
            result = pattern.match(interface, [neighbor])
            self.assertFalse(result)

        for remote_i in ['none', remote_interface + 'dummy']:
            pattern = InterfacePattern(interface, remote_device, 
                                       remote_i, random_string())
            neighbor = Neighbor(remote_device, remote_interface)
            result = pattern.match(interface, [neighbor])
            self.assertFalse(result)

        for remote_d in ['none', remote_device + 'dummy']:
            for remote_i in ['none', remote_interface + 'dummy']:
                pattern = InterfacePattern(interface, remote_d, 
                                           remote_i, random_string())
                neighbor = Neighbor(remote_device, remote_interface)
                result = pattern.match(interface, [neighbor])
                self.assertFalse(result)

        for intf in ['none', interface + 'dummy']:
            for remote_i in ['none', remote_interface + 'dummy']:
                pattern = InterfacePattern(intf, remote_device, 
                                           remote_i, random_string())
                neighbor = Neighbor(remote_device, remote_interface)
                result = pattern.match(interface, [neighbor])
                self.assertFalse(result)

        for intf in ['none', interface + 'dummy']:
            for remote_d in ['none', remote_device + 'dummy']:
                pattern = InterfacePattern(intf, remote_d, 
                                           remote_interface, random_string())
                neighbor = Neighbor(remote_device, remote_interface)
                result = pattern.match(interface, [neighbor])
                self.assertFalse(result)

        for intf in ['none', interface + 'dummy']:
            for remote_d in ['none', remote_device + 'dummy']:
                for remote_i in ['none', remote_interface + 'dummy']:
                    pattern = InterfacePattern(intf, remote_d, 
                                               remote_i, random_string())
                    neighbor = Neighbor(remote_device, remote_interface)
                    result = pattern.match(interface, [neighbor])
                    self.assertFalse(result)

    def test_create_pattern_kwargs(self):
        kwargs = dict(name=random_string(),
                      definition=random_string(),
                      interfaces=None)

        pattern = Pattern(**kwargs)
        self.assertIsInstance(pattern, Pattern)

    def test_add_interface_failure(self):
        kwargs = dict(name=random_string(),
                      definition=random_string(),
                      interfaces=None)

        pattern = Pattern(**kwargs)
        self.assertRaises(PatternError, pattern.add_interface, 
                          random_string())

    def test_file_exists(self):
        filename = random_string()
        contents = random_string()
        filepath = os.path.join(self.filepath, filename)
        write_file(contents, filepath)
        assert os.path.exists(filepath)

        self.assertTrue(self.filestore.exists(filename))

    def test_write_file(self):
        filename = random_string()
        contents = random_string()
        self.filestore.write_file(filename, contents)

        filepath = os.path.join(self.filepath, filename)
        self.assertTrue(os.path.exists(filepath))
        self.assertEqual(open(filepath).read(), contents)

    def test_delete_file(self):
        filename = random_string()
        contents = random_string()
        filepath = os.path.join(self.filepath, filename)
        write_file(contents, filepath)
        assert os.path.exists(filepath)

        self.filestore.delete_file(filename)
        self.assertFalse(os.path.exists(filename))

    def test_put_config_success(self):
        resource = random_string()
        body = random_string()
        request = Mock(content_type=constants.CONTENT_TYPE_OTHER, body=body)

        controller = ztpserver.controller.NodesController()
        resp = controller.put_config(request,
                                     resource=resource)

        self.assertEqual(resp, dict())

    def test_get_attributes_success(self, m_repository):
        cfg = {'return_value.read.return_value': random_string()}
        m_repository.return_value.get_file.configure_mock(**cfg)

        controller = ztpserver.controller.NodesController()
        (resp, state) = controller.get_attributes(dict(),
                                                  resource=random_string())

        self.assertEqual(state, 'do_substitution')
        self.assertIsInstance(resp, dict)

    def test_create_using_systemmac(self, m_repository):
        node = Mock(systemmac=random_string(), serialnumber=random_string())
        body = dict(systemmac=node.systemmac, serialnumber=node.serialnumber)

        request = Request.blank('/nodes')
        request.body = json.dumps(body)

        controller = ztpserver.controller.NodesController()
        with patch.object(controller, 'fsm') as m_fsm:
            controller.create(request)
            self.assertEqual(node.serialnumber, m_fsm.call_args[1]['node_id'])

    def test_do_put_config_invalid_content_type(self):
        filestore = Mock()
        ztpserver.controller.create_file_store = filestore

        resource = random_string()
        body = random_string()
        request = Mock(content_type='text/html', body=body)

        controller = ztpserver.controller.NodesController()
        self.assertRaises(AssertionError, controller.do_put_config, dict(),
                          resource=resource, request=request)

    def test_add_neighbor_existing_interface(self):
        systemmac = random_string()
        peer = Mock()
        intf = random_string()

        node = Node(systemmac=systemmac)
        node.add_neighbor(intf, [dict(device=peer.remote_device, 
                                      port=peer.remote_interface)])
        self.assertRaises(NodeError, node.add_neighbor,
                          intf, [dict(device=peer.remote_device, 
                                      port=peer.remote_interface)])

 def m_get_file(arg):
     fileobj = Mock()
     if arg.endswith('.node'):
         fileobj.read.return_value = node.as_dict()
     elif arg.endswith('startup-config'):
         fileobj.read.return_value = random_string()
     elif arg.endswith('pattern'):
         fileobj.read.return_value = random_string()
     else:
         raise ztpserver.repository.FileObjectNotFound
     return fileobj

    def test_get_file(self):

        filename = random_string()
        contents = random_string()
        filepath = os.path.join(self.filepath, filename)
        write_file(contents, filename=filepath)

        obj = self.filestore.get_file(filename)
        self.assertIsInstance(obj, ztpserver.repository.FileObject)
        self.assertTrue(obj.exists)
        self.assertEqual(filepath, obj.name)

    def test_post_config_success(self):
        request = Mock(json=dict(config=random_string()))
        node = Mock(serialnumber=random_string())

        controller = ztpserver.controller.NodesController()
        (resp, state) = controller.post_config(dict(), request=request,
                                               node=node, 
                                               node_id=node.serialnumber)

        self.assertEqual(state, 'set_location')
        self.assertIsInstance(resp, dict)
        self.assertEqual(resp['status'], constants.HTTP_STATUS_CREATED)

    def test_create_interface_pattern(self):
        intf = 'Ethernet1'
        remote_device = random_string()
        remote_interface = random_string()

        obj = InterfacePattern(intf, remote_device,
                               remote_interface,
                               random_string())
        reprobj = 'InterfacePattern(interface=%s, remote_device=%s, ' \
                   'remote_interface=%s)' % \
                  (intf, remote_device, remote_interface)
        self.assertEqual(repr(obj), reprobj)

    def test_do_put_config_invalid_resource(self):
        filestore = Mock()
        filestore.return_value.write_file = Mock(side_effect=IOError)
        ztpserver.controller.create_file_store = filestore

        resource = random_string()
        body = random_string()
        request = Mock(content_type='text/plain', body=body)

        controller = ztpserver.controller.NodesController()
        self.assertRaises(IOError, controller.do_put_config, dict(),
                          resource=resource, request=request)

    def test_get_definition_w_attributes_no_substitution(self):
        ztpserver.config.runtime.set_value(\
            'disable_topology_validation', False, 'default')

        node = create_node()

        g_attr_foo = random_string()
        attributes_file = create_attributes()
        attributes_file.add_attribute('variables', {'foo': g_attr_foo})

        l_attr_url = random_string()
        definitions_file = create_definition()
        definitions_file.add_attribute('foo', random_string())
        definitions_file.add_action(name='dummy action',
                                    attributes=dict(url=l_attr_url))

        filestore = Mock()

        def exists(filepath):
            if filepath.endswith('startup-config'):
                return False
            return True
        filestore.return_value.exists = Mock(side_effect=exists)

        def get_file(filepath):
            fileobj = Mock()
            if filepath.endswith('node'):
                fileobj.contents = node.as_json()
            elif filepath.endswith('definition'):
                fileobj.contents = definitions_file.as_yaml()
            elif filepath.endswith('attributes'):
                fileobj.contents = attributes_file.as_yaml()
            return fileobj
        filestore.return_value.get_file = Mock(side_effect=get_file)

        ztpserver.controller.create_file_store = filestore

        ztpserver.neighbordb.load_pattern = Mock()
        cfg = {'return_value.match_node.return_value': True}
        ztpserver.neighbordb.load_pattern.configure_mock(**cfg)

        url = '/nodes/%s' % node.systemmac
        request = Request.blank(url, method='GET')
        resp = request.get_response(ztpserver.controller.Router())

        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.content_type, 'application/json')

        attrs = resp.json['actions'][0]['attributes']
        self.assertFalse('variables' in attrs)
        self.assertFalse('foo' in attrs)
        self.assertEqual(attrs['url'], l_attr_url)

    def test_success(self):
        filename = random_string()
        contents = random_string()

        filepath = write_file(contents, filename)
        path = os.path.dirname(filepath)
        assert os.path.exists(filepath)

        obj = FileObject(filename, path=path)

        self.assertTrue(obj.name, filepath)
        self.assertTrue(obj.exists)
        self.assertEqual(obj.contents, contents)