# -*- coding: utf-8 -*-
# Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
#
# Author: Chmouel Boudjnah <chmouel@enovance.com>
#
# 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.

import eventlet
import swiftclient
import keystoneclient.v2_0.client  # noqa

from swsync.utils import get_config
from swsync import filler
import base as test_base
from fakes import FakeSWConnection, FakeKSClient, FakeKSUser


class TestFiller(test_base.TestCase):
    def setUp(self):
        super(TestFiller, self).setUp()
        self._stubs()

    def _stubs(self):
        self.stubs.Set(swiftclient.client, 'Connection',
                       FakeSWConnection)

    def get_connection(self, *args):
        return swiftclient.client.Connection(get_config(
                                             'auth', 'keystone_origin'),
                                             'test', 'password',
                                             tenant_name='test')

    def test_create_containers(self):
        get_containers_created = []
        return_dict_ref = {}

        def put_container(*args, **kwargs):
            get_containers_created.append(args[1])

        self.stubs.Set(FakeSWConnection, 'put_container', put_container)
        cnx = self.get_connection()
        filler.create_containers(cnx, 'test', 3, return_dict_ref)
        self.assertEqual(len(get_containers_created), 3)
        self.assertEqual(get_containers_created[0].split('_')[0],
                         'container')
        meta_amount = len(return_dict_ref['test'].values())
        self.assertEqual(meta_amount, 3)

    def test_create_objects(self):
        get_object_created = []
        return_dict_ref = {'test': {'container_a': {'objects': []},
                                    'container_b': {'objects': []}}}

        def put_object(*args, **kwargs):
            get_object_created.append(args[1:])

        self.stubs.Set(FakeSWConnection,
                       'put_object',
                       put_object)
        cnx = self.get_connection()
        filler.create_objects(cnx, 'test', 2, 2048, return_dict_ref)
        objects_ca = return_dict_ref['test']['container_a']['objects']
        objects_cb = return_dict_ref['test']['container_b']['objects']
        self.assertEqual(len(objects_ca), 2)
        self.assertEqual(len(objects_cb), 2)

    def test_fill_swift(self):
        self.cont_cnt = 0
        self.obj_cnt = 0
        return_dict_ref = {}

        def create_objects(*args, **kwargs):
            self.obj_cnt += 1

        def create_containers(*args, **kwargs):
            self.cont_cnt += 1

        def swift_cnx(*args, **kargs):
            return self.get_connection()

        self.stubs.Set(filler, 'swift_cnx', swift_cnx)
        self.stubs.Set(filler, 'create_objects', create_objects)
        self.stubs.Set(filler, 'create_containers', create_containers)

        concurrency = int(get_config('filler', 'concurrency'))
        pool = eventlet.GreenPool(concurrency)

        created = {('account1', 'account1_id'): ['test', 'test_id', 'role_id'],
                   ('account2', 'account2_id'): ['test', 'test_id', 'role_id']}
        filler.fill_swift(pool, created, 1, 1, 2048, return_dict_ref)
        self.assertEqual(self.cont_cnt, 2)
        self.assertEqual(self.obj_cnt, 2)

    def test_create_swift_user(self):
        self.create_cnt = 0
        self.role_cnt = 0

        def create(*args, **kargs):
            self.create_cnt += 1
            return FakeKSUser()

        def add_user_role(*args, **kargs):
            self.role_cnt += 1

        co = get_config('auth', 'keystone_origin_admin_credentials').split(':')
        tenant_name, username, password = co
        client = FakeKSClient()
        client.roles.add_user_role = add_user_role
        client.users.create = create
        filler.create_swift_user(client, 'account1', 'account1_id', 1)

        self.assertEqual(self.create_cnt, 1)
        self.assertEqual(self.role_cnt, 1)

    def test_create_swift_account(self):
        self.ret_index = {}
        self.user_cnt = 0

        def create_swift_user(*args):
            self.user_cnt += 1

        self.stubs.Set(filler, 'create_swift_user', create_swift_user)

        concurrency = int(get_config('filler', 'concurrency'))
        pile = eventlet.GreenPile(concurrency)
        client = FakeKSClient()
        filler.create_swift_account(client, pile, 1, 1, self.ret_index)

        self.assertEqual(self.user_cnt, 1)
        self.assertEqual(len(self.ret_index.keys()), 1)

    def test_delete_account(self):
        self.delete_t_cnt = 0
        self.delete_u_cnt = 0

        def delete_t(*args):
            self.delete_t_cnt += 1

        def delete_u(*args):
            self.delete_u_cnt += 1

        client = FakeKSClient()
        client.tenants.delete = delete_t
        client.users.delete = delete_u
        filler.delete_account(client,
                              [FakeKSUser().id, ],
                              ('account1', 'account1_id'))

        self.assertEqual(self.delete_t_cnt, 1)
        self.assertEqual(self.delete_u_cnt, 1)

    def test_delete_account_content(self):
        self.cnt_ga = 0
        self.cnt_co = 0
        self.cnt_do = 0

        filler.swift_cnx = self.get_connection

        def get_account(*args, **kwargs):
            self.cnt_ga += 1
            return (None, ({'name': 'cont1'}, {'name': 'cont2'}))

        def get_container(*args, **kwargs):
            self.cnt_co += 1
            return (None, ({'name': 'obj1'}, {'name': 'obj2'}))

        def delete_object(*args, **kwargs):
            self.cnt_do += 1

        self.stubs.Set(FakeSWConnection, 'get_account', get_account)
        self.stubs.Set(FakeSWConnection, 'get_container', get_container)
        self.stubs.Set(FakeSWConnection, 'delete_object', delete_object)

        filler.delete_account_content('account1', ['user', 'user_id'])

        self.assertEqual(self.cnt_ga, 1)
        self.assertEqual(self.cnt_co, 2)
        self.assertEqual(self.cnt_do, 4)