# coding: utf-8
require 'ostruct'
require_relative '../../acceptance_helper'
require_relative '../../factories/organizations_contexts'
require 'carto/user_authenticator'
require 'helpers/account_types_helper'

feature "Superadmin's users API" do
  include Carto::UserAuthenticator
  include AccountTypesHelper

  background do
    Capybara.current_driver = :rack_test
    @new_user = new_user(password: "this_is_a_password")
    @user_atts = @new_user.values
  end

  before(:all) do
    @account_type = create_account_type_fg('FREE')
    @account_type_juliet = create_account_type_fg('Juliet')
  end

  after(:all) do
    @account_type.destroy if @account_type
    @account_type_juliet.destroy if @account_type_juliet
  end

  scenario "Http auth is needed" do
    post_json superadmin_users_path, format: "json" do |response|
      response.status.should == 401
    end
  end

  scenario "user create fail" do
    @user_atts[:email] = nil

    post_json superadmin_users_path, { user: @user_atts }, superadmin_headers do |response|
      response.status.should == 422
      response.body[:errors][:email].should be_present
      response.body[:errors][:email].should include("is not present")
    end
  end

  scenario "user create with password success" do
    @user_atts.delete(:crypted_password)
    @user_atts.merge!(password: "this_is_a_password")

    CartoDB::UserModule::DBService.any_instance.stubs(:enable_remote_db_user).returns(true)
    post_json superadmin_users_path, { user: @user_atts }, superadmin_headers do |response|
      response.status.should == 201
      response.body[:email].should == @user_atts[:email]
      response.body[:username].should == @user_atts[:username]
      response.body.should_not have_key(:crypted_password)

      # Double check that the user has been created properly
      user = ::User.filter(email: @user_atts[:email]).first
      user.should be_present
      user.id.should == response.body[:id]
      authenticate(user.username, "this_is_a_password").should == user
    end
    ::User.where(username: @user_atts[:username]).first.destroy
  end

  scenario "user create with crypted_password success" do
    CartoDB::UserModule::DBService.any_instance.stubs(:enable_remote_db_user).returns(true)
    post_json superadmin_users_path, { user: @user_atts }, superadmin_headers do |response|
      response.status.should == 201
      response.body[:email].should == @user_atts[:email]
      response.body[:username].should == @user_atts[:username]
      response.body.should_not have_key(:crypted_password)

      # Double check that the user has been created properly
      user = ::User.filter(email: @user_atts[:email]).first
      user.should be_present
      user.id.should == response.body[:id]
      authenticate(user.username, "this_is_a_password").should == user
    end
    ::User.where(username: @user_atts[:username]).first.destroy
  end

  scenario "user create default account settings" do
    @user_atts[:private_tables_enabled] = false
    @user_atts[:sync_tables_enabled] = false
    @user_atts[:map_view_quota] = 80
    t = Time.now
    @user_atts[:upgraded_at] = t

    CartoDB::UserModule::DBService.any_instance.stubs(:enable_remote_db_user).returns(true)
    post_json superadmin_users_path, { user: @user_atts }, superadmin_headers do |response|
      response.status.should == 201
      response.body[:quota_in_bytes].should == 104857600
      response.body[:table_quota].should == 5
      response.body[:public_map_quota].should == nil
      response.body[:public_dataset_quota].should == nil
      response.body[:private_map_quota].should == nil
      response.body[:regular_api_key_quota].should == nil
      response.body[:account_type].should == 'FREE'
      response.body[:private_tables_enabled].should == false
      response.body[:sync_tables_enabled].should == false
      response.body[:map_view_quota].should == 80

      # Double check that the user has been created properly
      user = ::User.filter(email: @user_atts[:email]).first
      user.quota_in_bytes.should == 104857600
      user.table_quota.should == 5
      user.public_map_quota.should == nil
      user.public_dataset_quota.should == nil
      user.private_map_quota.should == nil
      user.regular_api_key_quota.should == nil
      user.account_type.should == 'FREE'
      user.private_tables_enabled.should == false
      user.upgraded_at.should.to_s == t.to_s
    end
    ::User.where(username: @user_atts[:username]).first.destroy
  end

  scenario "user create with rate limits" do
    t = Time.now
    @user_atts[:upgraded_at] = t
    rate_limits = FactoryGirl.create(:rate_limits)
    @user_atts[:rate_limit] = rate_limits.api_attributes

    CartoDB::UserModule::DBService.any_instance.stubs(:enable_remote_db_user).returns(true)
    post_json superadmin_users_path, { user: @user_atts }, superadmin_headers do |response|
      response.status.should == 201
      response.body[:rate_limit_id].should_not be_nil

      # Double check that the user has been created properly
      user = ::User.filter(email: @user_atts[:email]).first
      user.rate_limit.api_attributes.should eq @user_atts[:rate_limit]
    end
    ::User.where(username: @user_atts[:username]).first.destroy
    rate_limits.destroy
  end

  scenario "user create non-default account settings" do
    @user_atts[:quota_in_bytes] = 2000
    @user_atts[:table_quota] = 20
    @user_atts[:public_map_quota] = 20
    @user_atts[:public_dataset_quota] = 20
    @user_atts[:private_map_quota] = 20
    @user_atts[:regular_api_key_quota] = 20
    @user_atts[:account_type] = 'Juliet'
    @user_atts[:private_tables_enabled] = true
    @user_atts[:sync_tables_enabled] = true
    @user_atts[:map_view_block_price] = 15
    @user_atts[:geocoding_quota] = 15
    @user_atts[:geocoding_block_price] = 2
    @user_atts[:here_isolines_quota] = 100
    @user_atts[:here_isolines_block_price] = 5
    @user_atts[:obs_snapshot_quota] = 100
    @user_atts[:obs_snapshot_block_price] = 5
    @user_atts[:obs_general_quota] = 100
    @user_atts[:obs_general_block_price] = 5
    @user_atts[:notification] = 'Test'

    CartoDB::UserModule::DBService.any_instance.stubs(:enable_remote_db_user).returns(true)
    post_json superadmin_users_path, { user: @user_atts }, superadmin_headers do |response|
      response.status.should == 201
      response.body[:quota_in_bytes].should == 2000
      response.body[:table_quota].should == 20
      response.body[:public_map_quota].should == 20
      response.body[:public_dataset_quota].should == 20
      response.body[:private_map_quota].should == 20
      response.body[:regular_api_key_quota].should == 20
      response.body[:account_type].should == 'Juliet'
      response.body[:private_tables_enabled].should == true
      response.body[:sync_tables_enabled].should == true
      response.body[:sync_tables_enabled].should == true
      response.body[:map_view_block_price].should == 15
      response.body[:geocoding_quota].should == 15
      response.body[:geocoding_block_price].should == 2
      response.body[:here_isolines_quota].should == 100
      response.body[:here_isolines_block_price].should == 5
      response.body[:obs_snapshot_quota].should == 100
      response.body[:obs_snapshot_block_price].should == 5
      response.body[:obs_general_quota].should == 100
      response.body[:obs_general_block_price].should == 5
      response.body[:notification].should == 'Test'

      # Double check that the user has been created properly
      user = ::User.filter(email: @user_atts[:email]).first
      user.quota_in_bytes.should == 2000
      user.table_quota.should == 20
      user.public_map_quota.should == 20
      user.public_dataset_quota.should == 20
      user.private_map_quota.should == 20
      user.regular_api_key_quota.should == 20
      user.account_type.should == 'Juliet'
      user.private_tables_enabled.should == true
      user.sync_tables_enabled.should == true
      user.map_view_block_price.should == 15
      user.geocoding_quota.should == 15
      user.geocoding_block_price.should == 2
      user.here_isolines_quota.should == 100
      user.here_isolines_block_price.should == 5
      user.obs_snapshot_quota.should == 100
      user.obs_snapshot_block_price.should == 5
      user.obs_general_quota.should == 100
      user.obs_general_block_price.should == 5
      user.notification.should == 'Test'
    end
    ::User.where(username: @user_atts[:username]).first.destroy
  end

  scenario "update user account details" do
    user = create_user
    t = Time.now
    @update_atts = { quota_in_bytes: 2000,
                     table_quota: 20,
                     public_map_quota: 20,
                     public_dataset_quota: 20,
                     private_map_quota: 20,
                     regular_api_key_quota: 20,
                     max_layers: 10,
                     user_timeout: 100000,
                     database_timeout: 200000,
                     account_type: 'Juliet',
                     private_tables_enabled: true,
                     sync_tables_enabled: true,
                     upgraded_at: t,
                     map_view_block_price: 200,
                     geocoding_quota: 230,
                     geocoding_block_price: 5,
                     here_isolines_quota: 250,
                     here_isolines_block_price: 10,
                     obs_snapshot_quota: 250,
                     obs_snapshot_block_price: 10,
                     obs_general_quota: 250,
                     obs_general_block_price: 10,
                     notification: 'Test',
                     available_for_hire: true,
                     disqus_shortname: 'abc',
                     builder_enabled: true }

    # test to true
    put_json superadmin_user_path(user), { user: @update_atts }, superadmin_headers do |response|
      response.status.should == 204
    end
    user = ::User[user.id]
    user.quota_in_bytes.should == 2000
    user.table_quota.should == 20
    user.public_map_quota.should == 20
    user.public_dataset_quota.should == 20
    user.private_map_quota.should == 20
    user.regular_api_key_quota.should == 20
    user.account_type.should == 'Juliet'
    user.private_tables_enabled.should == true
    user.sync_tables_enabled.should == true
    user.max_layers.should == 10
    user.database_timeout.should == 200000
    user.user_timeout.should == 100000
    user.upgraded_at.to_s.should == t.to_s
    user.map_view_block_price.should == 200
    user.geocoding_quota.should == 230
    user.geocoding_block_price.should == 5
    user.here_isolines_quota.should == 250
    user.here_isolines_block_price.should == 10
    user.obs_snapshot_quota.should == 250
    user.obs_snapshot_block_price.should == 10
    user.obs_general_quota.should == 250
    user.obs_general_block_price.should == 10
    user.notification.should == 'Test'
    user.disqus_shortname.should == 'abc'
    user.available_for_hire.should == true
    user.builder_enabled.should == true

    # then test back to false
    put_json superadmin_user_path(user), { user: {
      private_tables_enabled: false,
      builder_enabled: false }
    }, superadmin_headers do |response|
      response.status.should == 204
    end
    user = ::User[user.id]
    user.private_tables_enabled.should == false
    user.map_view_block_price.should == 200
    user.geocoding_quota.should == 230
    user.geocoding_block_price.should == 5
    user.here_isolines_quota.should == 250
    user.here_isolines_block_price.should == 10
    user.obs_snapshot_quota.should == 250
    user.obs_snapshot_block_price.should == 10
    user.obs_general_quota.should == 250
    user.obs_general_block_price.should == 10
    user.notification.should == 'Test'
    user.builder_enabled.should == false

    user.destroy
  end

  scenario "user update fail" do
    user = create_user

    put_json superadmin_user_path(user), { user: { email: "" } }, superadmin_headers do |response|
      response.status.should == 422
    end

    user.destroy
  end

  scenario "user update success" do
    user = create_user
    put_json superadmin_user_path(user),
             { user: { email: "newmail@test.com", map_view_quota: 80 } },
             superadmin_headers do |response|
      response.status.should == 204
    end
    user = ::User[user.id]
    user.email.should == "newmail@test.com"
    user.map_view_quota.should == 80

    user.destroy
  end

  scenario "update success with new organization" do
    pending "Organizations handling has been refactored and needs new specs"
    user = create_user
    @update_atts = {
      quota_in_bytes: 2000,
      organization_attributes: { name: 'wadus', seats: 25, quota_in_bytes: 40000 }
    }

    put_json superadmin_user_path(user), { user: @update_atts }, superadmin_headers do |response|
      response.status.should eq 204
    end
    user = ::User[user.id]
    user.quota_in_bytes.should eq 2000
    user.organization.name.should eq 'wadus'
    user.organization.seats.should eq 25
    user.organization.quota_in_bytes.should eq 40000

    @update_atts = {
      quota_in_bytes: 2001,
      organization_attributes: { name: 'wadus', seats: 26 }
    }
    put_json superadmin_user_path(user), { user: @update_atts }, superadmin_headers do |response|
      response.status.should eq 204
    end
    user = ::User[user.id]
    user.quota_in_bytes.should eq 2001
    user.organization.name.should eq 'wadus'
    user.organization.seats.should eq 26
    user.organization.quota_in_bytes.should eq 40000

    user.destroy
  end

  scenario "user delete success" do
    user = create_user
    delete_json superadmin_user_path(user), {}, superadmin_headers do |response|
      response.status.should == 204
    end
    ::User[user.id].should be_nil
  end

  scenario "user dump success" do
    user = create_user
    dump_url = %r{#{user.database_host}:[0-9]+/scripts/db_dump}
    json_data = { database: user.database_name, username: user.username }
    response_body = {
      retcode: 0,
      return_values: {
        local_file: '/tmp/foo.sql.gz',
        remote_file: 's3://foo-bucket/backups/foo.sql.gz'
      }
    }
    Typhoeus.stub(dump_url,
                  method: :post
                 )
      .and_return(
        Typhoeus::Response.new(code: 200, body: response_body.to_json)
      )

    get_json "/superadmin/users/#{user.id}/dump", {}, superadmin_headers do |response|
      response.status.should == 200
      response.body['retcode'] == 0
    end
    user.destroy
  end

  scenario "user dump fail" do
    user = create_user
    dump_url = %r{#{user.database_host}:[0-9]+/scripts/db_dump}
    json_data = { database: user.database_name, username: user.username }
    Typhoeus.stub(dump_url,
                  method: :post
                 )
      .and_return(
        Typhoeus::Response.new(code: 200, body: '{"retcode": 111}')
      )

    get_json "/superadmin/users/#{user.id}/dump", {}, superadmin_headers do |response|
      response.status.should == 400
      response.body['retcode'] != 0
    end
    user.destroy
  end

  scenario "user dump fail retcode" do
    user = create_user
    dump_url = %r{#{user.database_host}:[0-9]+/scripts/db_dump}
    json_data = { database: user.database_name, username: user.username }
    Typhoeus.stub(dump_url,
                  method: :post
                 )
      .and_return(
        Typhoeus::Response.new(code: 500, body: '{"retcode": 0}')
      )

    get_json "/superadmin/users/#{user.id}/dump", {}, superadmin_headers do |response|
      response.status.should == 400
    end
    user.destroy
  end

  scenario "user get info success" do
    user = create_user
    get_json superadmin_user_path(user), {}, superadmin_headers do |response|
      response.status.should == 200
      response.body[:id].should == user.id
    end

    get_json superadmin_user_path(user.id), {}, superadmin_headers do |response|
      response.status.should == 200
      response.body[:id].should == user.id
    end

    get_json superadmin_user_path(user.username), {}, superadmin_headers do |response|
      response.status.should == 200
      response.body[:id].should == user.id
    end

    user.destroy
  end

  scenario "user get info fail" do
    get_json superadmin_user_path('7b77546f-79cb-4662-9439-9ebafd9627cb'), {}, superadmin_headers do |response|
      response.status.should == 404
    end

    get_json superadmin_user_path('nonexistinguser'), {}, superadmin_headers do |response|
      response.status.should == 404
    end
  end

  describe "GET /superadmin/users" do
    before do
      @user  = create_user
      @user2 = create_user
      @user3 = create_user
      @user4 = create_user
    end

    after do
      @user&.destroy
      @user2&.destroy
      @user3&.destroy
      @user4&.destroy
    end

    it "gets all users" do
      get_json superadmin_users_path, {}, superadmin_headers do |response|
        response.status.should == 200
        response.body.map { |u| u["username"] }.should include(@user.username, @user2.username)
        response.body.length.should >= 2
      end
    end

    it "gets overquota users" do
      ::User.stubs(:overquota).returns [@user]
      Carto::OverquotaUsersService.any_instance.stubs(:get_stored_overquota_users).returns [@user.data]
      get_json superadmin_users_path, { overquota: true }, superadmin_headers do |response|
        response.status.should == 200
        response.body[0]["username"].should == @user.username
        response.body.length.should == 1
      end
    end

    it "gets active Juliet users" do
      @user3.account_type = 'Juliet'
      @user3.state = 'active'
      @user3.save

      @user4.account_type = 'Juliet'
      @user4.state = 'locked'
      @user4.save

      get_json superadmin_users_path, { account_type: 'Juliet', state: 'active' }, superadmin_headers do |response|
        response.status.should == 200
        response.body.length.should eq 1
        response.body[0]["username"].should == @user3.username
        response.body[0].has_key?('table_count').should eq true
        response.body[0].has_key?('public_map_count').should eq true
        response.body[0].has_key?('map_count').should eq true
        response.body[0].has_key?('geocoding_credits_count').should eq true
        response.body[0].has_key?('routing_credits_count').should eq true
        response.body[0].has_key?('isolines_credits_count').should eq true
        response.body[0].has_key?('billing_period').should eq true
        response.body[0].has_key?('regular_api_key_count').should eq true
        response.body[0].has_key?('map_views').should eq true
      end
    end

    it "gets cached db_size_in_bytes_change_users and returns username and db_size_in_bytes_change" do
      cached_users_mock = {
        'username1' => 1111,
        'username2' => 2222
      }
      Carto::UserDbSizeCache.any_instance.expects(:db_size_in_bytes_change_users).once.returns(cached_users_mock)

      get_json superadmin_users_path, { db_size_in_bytes_change: true }, superadmin_headers do |response|
        response.status.should == 200
        users = response.body
        users.length.should == cached_users_mock.length
        users.each do |user|
          user.keys.should == ['username', 'db_size_in_bytes']
        end
        users.each.map { |u| u['username'] }.sort.should == cached_users_mock.keys.sort
        users.each.map { |u| u['db_size_in_bytes'] }.sort.should == cached_users_mock.values.sort
      end
    end

    it "doesn't get organization users" do
      ::User.stubs(:organization).returns(Organization.new)
      ::User.stubs(:organization_id).returns("organization-id")
      get_json superadmin_users_path, { overquota: true }, superadmin_headers do |response|
        response.status.should == 200
        response.body.length.should == 0
      end
    end
  end

  describe '#update' do
    it 'should remove user feature_flag relation' do
      user                = FactoryGirl.create(:user)
      first_feature_flag  = FactoryGirl.create(:feature_flag)
      second_feature_flag = FactoryGirl.create(:feature_flag)

      user.activate_feature_flag!(first_feature_flag)
      user.activate_feature_flag!(second_feature_flag)

      expect do
        put superadmin_user_url(user.id), {
          user: { feature_flags: [second_feature_flag.id] }, id: user.id
        }.to_json, superadmin_headers
      end.to change(Carto::FeatureFlagsUser, :count).by(-1)
    end

    it 'should create user feature_flag relation' do
      user = create(:user)
      feature_flag = create(:feature_flag)
      user.activate_feature_flag!(feature_flag)
      new_feature_flag = create(:feature_flag)

      payload = {
        user: { feature_flags: [feature_flag.id, new_feature_flag.id] },
        id: user.id
      }

      expect do
        put superadmin_user_url(user.id), payload.to_json, superadmin_headers
      end.to change(Carto::FeatureFlagsUser, :count).by(1)
    end

    it 'should create new rate limit if user does not have' do
      user        = FactoryGirl.create(:user)
      rate_limit  = FactoryGirl.create(:rate_limits)

      expect {
        put superadmin_user_url(user.id), {
          user: { rate_limit: rate_limit.api_attributes }, id: user.id
        }.to_json, superadmin_headers

        user.reload
        user.rate_limit.api_attributes.should eq rate_limit.api_attributes

      }.to change(Carto::RateLimit, :count).by(1)
    end

    it 'should update existing user rate limit' do
      user        = FactoryGirl.create(:user)
      rate_limit  = FactoryGirl.create(:rate_limits)
      user.rate_limit_id = rate_limit.id
      user.save
      rate_limit_custom = FactoryGirl.create(:rate_limits_custom)

      put superadmin_user_url(user.id), {
        user: { rate_limit: rate_limit_custom.api_attributes }, id: user.id
      }.to_json, superadmin_headers

      user.reload
      user.rate_limit.api_attributes.should eq rate_limit_custom.api_attributes
    end

    describe 'gcloud settings' do

      before(:all) do
        @user = FactoryGirl.create(:user)
      end

      after(:all) do
        @user.destroy
      end

      after(:each) do
        $users_metadata.del("do_settings:#{@user.username}")
      end

      it 'gcloud settings are updated in redis' do
        expected_gcloud_settings = {
          service_account: {
            type: 'service_account',
            project_id: 'my_project_id',
            private_key_id: 'my_private_key_id'
          }.to_json,
          bq_public_project: 'my_public_project',
          gcp_execution_project: 'my_gcp_execution_project',
          bq_project: 'my_bq_project',
          gcs_bucket: 'my_gcs_bucket',
          bq_dataset: 'my_bq_dataset'
        }

        payload = {
          user: {
            gcloud_settings: expected_gcloud_settings
          }
        }
        put superadmin_user_url(@user.id), payload.to_json, superadmin_headers do |response|
          response.status.should == 204
        end

        redis_gcloud_settings = $users_metadata.hgetall("do_settings:#{@user.username}").symbolize_keys

        redis_gcloud_settings[:service_account].should == expected_gcloud_settings[:service_account]
        redis_gcloud_settings[:bq_public_project].should == expected_gcloud_settings[:bq_public_project]
        redis_gcloud_settings[:gcp_execution_project].should == expected_gcloud_settings[:gcp_execution_project]
        redis_gcloud_settings[:bq_project].should == expected_gcloud_settings[:bq_project]
        redis_gcloud_settings[:gcs_bucket].should == expected_gcloud_settings[:gcs_bucket]
        redis_gcloud_settings[:bq_dataset].should == expected_gcloud_settings[:bq_dataset]
      end

      it 'gclouds settings are set to blank when receiving empty hash' do
        dummy_settings = { bq_project: 'dummy_project' }
        $users_metadata.hmset("do_settings:#{@user.username}", *dummy_settings.to_a)

        payload = {
          user: {
            gcloud_settings: {}
          }
        }
        put superadmin_user_url(@user.id), payload.to_json, superadmin_headers do |response|
          response.status.should == 204
        end

        redis_gcloud_settings = $users_metadata.hgetall("do_settings:#{@user.username}")
        redis_gcloud_settings.should == {}
      end

      it 'An update without gcloud settings do not affect them' do
        expected_settings = { bq_project: 'dummy_project' }
        $users_metadata.hmset("do_settings:#{@user.username}", *expected_settings.to_a)

        payload = {
          user: {
            builder_enabled: true
          }
        }
        put superadmin_user_url(@user.id), payload.to_json, superadmin_headers do |response|
          response.status.should == 204
        end

        redis_gcloud_settings = $users_metadata.hgetall("do_settings:#{@user.username}").symbolize_keys
        redis_gcloud_settings.should == expected_settings
      end

      it 'An update without gcloud settings does not add an empty key to redis' do
        payload = {
          user: {
            #builder_enabled: true
          }
        }
        put superadmin_user_url(@user.id), payload.to_json, superadmin_headers do |response|
          response.status.should == 204
        end

        keys = $users_metadata.keys("do_settings:*")
        keys.should be_empty
      end
    end
  end

  describe '#destroy' do
    let!(:user) { create(:user).carto_user }

    it 'should destroy user' do
      delete superadmin_user_url(user.id), {}.to_json, superadmin_headers

      expect { user.reload }.to raise_error(ActiveRecord::RecordNotFound)
    end

    it 'should destroy user feature flag relations' do
      feature_flag = create(:feature_flag)
      user.activate_feature_flag!(feature_flag)

      expect do
        delete superadmin_user_url(user.id), { user: user }.to_json, superadmin_headers
      end.to change(Carto::FeatureFlagsUser, :count).by(-1)
    end

    it 'should destroy rate_limit' do
      rate_limit = create(:rate_limits)
      user.update!(rate_limit_id: rate_limit.id)

      expect {
        delete superadmin_user_url(user.id), { user: user }.to_json, superadmin_headers
      }.to change(Carto::RateLimit, :count).by(-1)
    end
  end

  describe 'with organization' do
    include_context 'organization with users helper'

    def update_and_verify(update_attrs)
      put_json superadmin_user_path(@org_user_1), { user: update_attrs }, superadmin_headers do |response|
        response.status.should eq 204
      end
      @org_user_1.reload
      update_attrs.keys.each do |att|
        @org_user_1.send(att).should eq update_attrs[att]
      end
    end

    it 'should update users' do
      update_attrs = {
        quota_in_bytes: 2000,
        table_quota: 20,
        public_map_quota: 20,
        public_dataset_quota: 20,
        private_map_quota: 20,
        regular_api_key_quota: 20,
        max_layers: 10,
        user_timeout: 100000,
        database_timeout: 200000,
        private_tables_enabled: true,
        sync_tables_enabled: true,
        map_view_block_price: 200,
        geocoding_quota: 230,
        geocoding_block_price: 5,
        here_isolines_quota: 250,
        here_isolines_block_price: 10,
        obs_snapshot_quota: 250,
        obs_snapshot_block_price: 10,
        obs_general_quota: 250,
        obs_general_block_price: 10,
        notification: 'Test',
        available_for_hire: true,
        disqus_shortname: 'abc',
        builder_enabled: true
      }

      update_and_verify(update_attrs)
      update_and_verify(builder_enabled: false)
      update_and_verify(builder_enabled: nil)
    end
  end

  describe '#data_imports' do
    before(:each) do
      @user = create_user
    end

    after(:each) do
      @user.destroy
    end

    it 'filters results if param status is present' do
      successful_data_import = FactoryGirl.create(:data_import, user_id: @user.id, success: true, state: 'complete')
      failed_data_import = FactoryGirl.create(:data_import, user_id: @user.id, success: false, state: 'failure')

      get_json("/superadmin/users/#{@user.id}/data_imports", { status: 'complete' }, superadmin_headers) do |response|
        expect(response.status).to eq(200)

        expect(response.body[:data_imports].size).to eq(1)
        expect(response.body[:data_imports].first[:id]).to eq(successful_data_import.id)
      end

      get_json("/superadmin/users/#{@user.id}/data_imports", { status: 'failure' }, superadmin_headers) do |response|
        expect(response.status).to eq(200)

        expect(response.body[:data_imports].size).to eq(1)
        expect(response.body[:data_imports].first[:id]).to eq(failed_data_import.id)
      end

      get_json("/superadmin/users/#{@user.id}/data_imports", {}, superadmin_headers) do |response|
        expect(response.status).to eq(200)
        expect(response.body[:data_imports].size).to eq(2)
      end
    end

    it 'paginates results' do
      data_imports = FactoryGirl.create_list(:data_import, 2, user_id: @user.id)
      data_import_ids = data_imports.map(&:id)

      pagination_params = { page: 1, per_page: 1 }

      expect(data_import_ids.size).to eq(2)

      get_json("/superadmin/users/#{@user.id}/data_imports", pagination_params, superadmin_headers) do |response|
        expect(response.status).to eq(200)

        expect(response.body[:data_imports].size).to eq(1)

        expect(response.body[:total_entries]).to eq(2)

        data_import_ids.delete_if { |id| id == response.body[:data_imports][0][:id] }
        expect(data_import_ids.size).to eq(1)
      end

      pagination_params = { page: 2, per_page: 1 }

      get_json("/superadmin/users/#{@user.id}/data_imports", pagination_params, superadmin_headers) do |response|
        expect(response.status).to eq(200)
        expect(response.body[:data_imports].size).to eq(1)

        expect(response.body[:total_entries]).to eq(2)

        data_import_ids.delete_if { |id| id == response.body[:data_imports][0][:id] }
        expect(data_import_ids.size).to eq(0)
      end
    end

    it 'returns all the data imports if no pagination params are present' do
      FactoryGirl.create_list(:data_import, 3, user_id: @user.id)

      get_json("/superadmin/users/#{@user.id}/data_imports", {}, superadmin_headers) do |response|
        expect(response.status).to eq(200)
        expect(response.body[:data_imports].size).to eq(3)
      end
    end

    it 'validates order param' do
      ['data_imports', 'geocodings', 'synchronizations'].each do |endpoint|
        get_json("/superadmin/users/#{@user.id}/#{endpoint}", { order: :updated_at }, superadmin_headers) do |response|
          response.status.should eq 200
        end

        get_json("/superadmin/users/#{@user.id}/#{endpoint}", { order: :invalid }, superadmin_headers) do |response|
          response.status.should eq 400
          response.body.fetch(:errors).should_not be_nil
        end
      end
    end
  end
end