require 'spec_helper'

describe CookieJar::Wallet::Banker do
  let!(:circulation) {
    {
      "id" => "circulation-id",
      "amount" => 1000,
      "state" => "initiated",
      "created_at" => Time.now,
      "updated_at" => Time.now
    }
  }

  let!(:user_id) { "user-id" }
  let!(:circulation_id) { circulation["id"] }
  let!(:amount) { 1000 }
  let!(:passcode) { 1000 }
  let!(:invalid_circulation_id) { "invalid-circulation-id" }
  let!(:user_ip) { "127.0.0.1" }
  let!(:invalid_ip) { "invalid-ip" }
  let!(:user_url) { "http://biscuit-aa.com/users/#{user_id}" }
  let!(:user_agent) { "user-agent" }
  let!(:insufficient_params_message) { {"message" => "Insufficient parameters."} }
  let!(:unauthorized_message) { {"message" => "You're not authorized to access the resource"} }
  let!(:circulation_not_found_message) { {"message" => "Couldn't find Transfer id=#{invalid_circulation_id}"} }
  let!(:circulation_already_activated_message) { {"message" => "Circulation is already activated."} }
  let!(:creation_failed_message) { {"message" => "Creation of circulation failed."} }

  before do
    CookieJar::Wallet::Banker.any_instance.stub(:init_token).and_return(double OAuth2::AccessToken)
    CookieJar::Wallet::Banker.any_instance.stub(:get_token).and_return(double OAuth2::AccessToken, :token => "sample1234")
    CookieJar::Wallet::Banker.any_instance.stub(:get_user_id).and_return(user_id)
  end

  let!(:user) { CookieJar::Wallet::Banker.new(*INITIALIZE_BANKER_VALUES) }

  context "#all_circulations" do
    context "successful" do
      before do
        user.stub(:get).and_return([circulation])
      end

      it "should return list of circulations" do
        user.all_circulations(user_url, user_ip, user_agent).should eql([circulation])
      end
    end

    context "on failure" do
      context "when params are not sufficient" do
        before do
          user.stub(:get).and_return(insufficient_params_message)
        end

        it "should return INSUFFICIENT_PARAMS error message." do
          expect {
            user.all_circulations("", user_ip, "")
          }.to raise_error(CookieJar::Error::InsufficientParams)
        end
      end

      context "when user_ip is not valid" do
        it "should return INVALID_IP_ADDRESS error message." do
          expect {
            user.all_circulations(user_url, invalid_ip, user_agent)
          }.to raise_error(CookieJar::Error::InvalidUserIP)
        end
      end

      context "when unauthorized" do
        before do
          user.stub(:get).and_return(unauthorized_message)
        end

        it "should raise ACCESS_DENIED error" do
          expect {
            user.all_circulations(user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::AccessDenied)
        end
      end
    end
  end

  context "#get_circulation" do
    context "successful" do
      before do
        user.stub(:get).and_return(circulation)
      end

      it "should return circulation's information" do
        user.get_circulation(circulation_id, user_url, user_ip, user_agent).should eql(circulation)
      end
    end

    context "on failure" do
      context "when unauthorized" do
        before do
          user.stub(:get).and_return(unauthorized_message)
        end

        it "should raise ACCESS_DENIED error" do
          expect {
            user.get_circulation(circulation_id, user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::AccessDenied)
        end
      end

      context "when unauthorized with 401 error code" do
        before do
          user.stub(:get).and_return({:code => 401, :message => "You're not authorized to access the resource"})
        end

        it "should raise ACCESS_DENIED error" do
          expect {
            user.get_circulation(circulation_id, user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::AccessDenied)
        end
      end

      context "when user_ip is not valid" do
        it "should raise USER IP NOT VALID error" do
          expect {
            user.get_circulation(circulation_id, user_url, invalid_ip, user_agent)
          }.to raise_error(CookieJar::Error::InvalidUserIP)
        end
      end

      context "when insufficient parameters" do
        before do
          user.stub(:get).and_return(insufficient_params_message)
        end
        it "should raise INSUFFICIENT parameters" do
          expect {
            user.get_circulation(circulation_id, "", user_ip, "")
          }.to raise_error(CookieJar::Error::InsufficientParams)
        end
      end

      context "when invalid circulation id" do
        before do
          user.stub(:get).and_return(circulation_not_found_message)
        end
        it "should raise CIRCULATION NOT FOUND error" do
          expect {
            user.get_circulation(invalid_circulation_id, user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::CirculationNotFound)
        end
      end
    end
  end

  context "#create_circulation" do
    context "successful" do
      before do
        user.stub(:post).and_return(circulation)
      end
      it "should create circulation" do
        user.create_circulation(amount, user_url, user_ip, user_agent).should eql(circulation)
      end
    end

    context "on failure" do
      context "when insufficient parameters" do
        before do
          user.stub(:post).and_return(insufficient_params_message)
        end
        it "should raise INSUFFICIENT parameters" do
          expect {
            user.create_circulation(circulation_id, "", user_ip, "")
          }.to raise_error(CookieJar::Error::InsufficientParams)
        end
      end

      context "when unauthorized" do
        before do
          user.stub(:post).and_return(unauthorized_message)
        end

        it "should raise ACCESS_DENIED error" do
          expect {
            user.create_circulation(circulation_id, user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::AccessDenied)
        end
      end

      context "when creation of circulation failed" do
        before do
          user.stub(:post).and_return(creation_failed_message)
        end

        it "should raise CREATION_FAILED error message" do
          expect {
            user.create_circulation(invalid_circulation_id, user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::CreateError)
        end
      end

      context "when user_ip is not valid" do
        it "should raise USER IP NOT VALID error" do
          expect {
            user.create_circulation(invalid_circulation_id, user_url, invalid_ip, user_agent)
          }.to raise_error(CookieJar::Error::InvalidUserIP)
        end
      end
    end
  end

  context "#activate_circulation" do
    context "successful" do
      before do
        user.stub(:put).and_return(circulation)
      end

      it "should activate circulation" do
        user.activate_circulation(circulation_id, user_url, user_ip, user_agent).should eql(circulation)
      end
    end

    context "on failure" do
      context "when unauthorized" do
        before do
          user.stub(:put).and_return(unauthorized_message)
        end

        it "should raise ACCESS_DENIED error" do
          expect {
            user.activate_circulation(circulation_id, user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::AccessDenied)
        end
      end

      context "when insufficient parameter" do
        before do
          user.stub(:put).and_return(insufficient_params_message)
        end
        it "should raise INSUFFICIENT parameters" do
          expect {
            user.activate_circulation(circulation_id, "", user_ip, "")
          }.to raise_error(CookieJar::Error::InsufficientParams)
        end
      end

      context "when invalid circulation id" do
        before do
          user.stub(:put).and_return(circulation_not_found_message)
        end
        it "should raise CIRCULATION NOT FOUND error" do
          expect {
            user.activate_circulation(invalid_circulation_id, user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::CirculationNotFound)
        end
      end

      context "when circulation is already activated" do
        before do
          user.stub(:put).and_return(circulation_already_activated_message)
        end
        it "should raise CIRCULATION NOT FOUND error" do
          expect {
            user.activate_circulation(invalid_circulation_id, user_url, user_ip, user_agent)
          }.to raise_error(CookieJar::Error::CirculationAlreadyActivated)
        end
      end

      context "when invalid USER IP" do
        it "should raise USER IP NOT VALID error" do
          expect {
            user.activate_circulation(invalid_circulation_id, user_url, invalid_ip, user_agent)
          }.to raise_error(CookieJar::Error::InvalidUserIP)
        end
      end
    end
  end
end