require 'rails_helper'

describe Domain do
  before :all do
    create_settings
  end

  it { should belong_to(:registrar) }
  it { should have_many(:nameservers) }
  it { should belong_to(:registrant) }
  it { should have_many(:tech_contacts) }
  it { should have_many(:admin_contacts) }
  it { should have_many(:domain_transfers) }
  it { should have_many(:dnskeys) }
  it { should have_many(:legal_documents) }

  context 'with invalid attribute' do
    before :all do
      @domain = Domain.new
    end

    it 'should not be valid' do
      @domain.valid?
      @domain.errors.full_messages.should match_array([
        "Admin domain contacts Admin contacts count must be between 1-10",
        "Nameservers Nameservers count must be between 2-11",
        "Period Period is not a number",
        "Registrant Registrant is missing",
        "Registrar Registrar is missing"
      ])
    end

    it 'should not have any versions' do
      @domain.versions.should == []
    end

    it 'should not have whois_body' do
      @domain.whois_body.should == nil
    end

    it 'should not have whois json' do
      @domain.whois_json.should == nil
    end
  end

  context 'with valid attributes' do
    before :all do
      @domain = Fabricate(:domain)
    end

    it 'should be valid' do
      @domain.valid?
      @domain.errors.full_messages.should match_array([])
    end

    it 'should be valid twice' do
      @domain = Fabricate(:domain)
      @domain.valid?
      @domain.errors.full_messages.should match_array([])
    end

    it 'should validate uniqueness of tech contacts' do
      same_contact = Fabricate(:contact, code: 'same_contact')
      domain = Fabricate(:domain)
      domain.tech_contacts << same_contact
      domain.tech_contacts << same_contact
      domain.valid?
      domain.errors.full_messages.should match_array(["Tech domain contacts is invalid"])
    end

    it 'should validate uniqueness of tech contacts' do
      same_contact = Fabricate(:contact, code: 'same_contact')
      domain = Fabricate(:domain)
      domain.admin_contacts << same_contact
      domain.admin_contacts << same_contact
      domain.valid?
      domain.errors.full_messages.should match_array(["Admin domain contacts is invalid"])
    end

    it 'should have whois body by default' do
      @domain.whois_body.present?.should == true
    end

    it 'should have whois json by default' do
      @domain.whois_json.present?.should == true
    end

    it 'should have whois_body present by default' do
      @domain.name = 'yeah.ee'
      @domain.updated_at    = Time.zone.parse('2020.02.02 02:00')
      @domain.registered_at = Time.zone.parse('2000.01.01 9:00')
      @domain.valid_to      = Time.zone.parse('2016.04.21 0:00')
      registrar = Fabricate(:registrar, 
                            name: 'First Registrar Ltd', 
                            created_at: Time.zone.parse('1995.01.01'),
                            updated_at: Time.zone.parse('1996.01.01'))
      @domain.registrant    = Fabricate(:contact, 
                                        name: 'Jarren Jakubowski0', 
                                        created_at: Time.zone.parse('2005.01.01'))
      @domain.admin_contacts = [Fabricate(:contact,
                                          name: 'First Admin', 
                                          registrar: registrar,
                                          created_at: Time.zone.parse('2016.01.01'))]
      @domain.tech_contacts = [Fabricate(:contact,
                                         name: 'First Tech', 
                                         registrar: registrar,
                                         created_at: Time.zone.parse('2016.01.01'))]
      @domain.registrar = registrar
      ns1 = Fabricate(:nameserver, hostname: 'test.ee')
      ns1.updated_at = Time.zone.parse('1980.01.01')
      ns2 = Fabricate(:nameserver, hostname: 'test1.ee')
      ns2.updated_at = Time.zone.parse('1970.01.01')
      @domain.nameservers = [ns1, ns2]

      @domain.update_whois_body
      @domain.whois_body.should == <<-EOS
Estonia .ee Top Level Domain WHOIS server

Domain:
  name:       yeah.ee
  registrant: Jarren Jakubowski0
  status:     ok (paid and in zone)
  registered: 2000-01-01 09:00:00 UTC
  changed:    2020-02-02 02:00:00 UTC
  expire:     2016-04-21 00:00:00 UTC
  outzone:
  delete:

Administrative contact
  name:       First Admin
  e-mail:     Not Disclosed - Visit www.internet.ee for webbased WHOIS
  registrar:  First Registrar Ltd
  created:    2016-01-01 00:00:00

Technical contact:
  name:       First Tech
  e-mail:     Not Disclosed - Visit www.internet.ee for webbased WHOIS
  registrar:  First Registrar Ltd
  created:    2016-01-01 00:00:00

Registrar:
  name:       First Registrar Ltd
  phone:      
  address:    Street 999, Town, County, Postal
  changed:    1996-01-01 00:00:00

Name servers:
  nserver:   test.ee
  changed:   1980-01-01 00:00:00

  nserver:   test1.ee
  changed:   1970-01-01 00:00:00

Estonia .ee Top Level Domain WHOIS server
More information at http://internet.ee
 EOS
    end

    context 'with versioning' do
      it 'should not have one version' do
        with_versioning do
          @domain.versions.size.should == 0
          @domain.name = 'new-test-name.ee'
          @domain.save
          @domain.errors.full_messages.should match_array([])
          @domain.versions.size.should == 1
        end
      end

      it 'should return api_creator when created by api user' do
        with_versioning do
          @user = Fabricate(:admin_user)
          @api_user = Fabricate(:api_user)
          @user.id.should == 1
          @api_user.id.should == 2
          ::PaperTrail.whodunnit = '2-api-testuser'

          @domain = Fabricate(:domain)
          @domain.creator_str.should == '2-api-testuser'

          @domain.creator.should == @api_user
          @domain.creator.should_not == @user
        end
      end

      it 'should return api_creator when created by api user' do
        with_versioning do
          @user = Fabricate(:admin_user)
          @api_user = Fabricate(:api_user)
          @user.id.should == 3
          @api_user.id.should == 4
          ::PaperTrail.whodunnit = '3-testuser'

          @domain = Fabricate(:domain)
          @domain.creator_str.should == '3-testuser'

          @domain.creator.should == @user
          @domain.creator.should_not == @api_user
        end
      end
    end
  end

  # it 'validates domain name', skip: true do
  # d = Fabricate(:domain)
  # expect(d.name).to_not be_nil

  # invalid = ['a.ee', "#{'a' * 64}.ee", 'ab.eu', 'test.ab.ee', '-test.ee', '-test-.ee', 'test-.ee', 'te--st.ee',
  # 'õ.pri.ee', 'test.com', 'www.ab.ee', 'test.eu', '  .ee', 'a b.ee', 'Ž .ee', 'test.edu.ee']

  # invalid.each do |x|
  # expect(Fabricate.build(:domain, name: x).valid?).to be false
  # end

  # valid = ['ab.ee', "#{'a' * 63}.ee", 'te-s-t.ee', 'jäääär.ee', 'päike.pri.ee',
  # 'õigus.com.ee', 'õäöü.fie.ee', 'test.med.ee', 'žä.ee', '  ŽŠ.ee  ']

  # valid.each do |x|
  # expect(Fabricate.build(:domain, name: x).valid?).to be true
  # end

  # invalid_punycode = ['xn--geaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-4we.pri.ee']

  # invalid_punycode.each do |x|
  # expect(Fabricate.build(:domain, name: x).valid?).to be false
  # end

  # valid_punycode = ['xn--ge-uia.pri.ee', 'xn--geaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-9te.pri.ee']

  # valid_punycode.each do |x|
  # expect(Fabricate.build(:domain, name: x).valid?).to be true
  # end

  # d = Domain.new
  # expect(d.valid?).to be false
  # expect(d.errors.messages).to match_array({
  # registrant: ['Registrant is missing'],
  # admin_contacts: ['Admin contacts count must be between 1 - infinity'],
  # nameservers: ['Nameservers count must be between 2-11'],
  # registrar: ['Registrar is missing'],
  # period: ['Period is not a number']
  # })

  # Setting.ns_min_count = 2
  # Setting.ns_max_count = 7

  # expect(d.valid?).to be false
  # expect(d.errors.messages[:nameservers]).to eq(['Nameservers count must be between 2-7'])
  # end

  it 'downcases domain' do
    d = Domain.new(name: 'TesT.Ee')
    expect(d.name).to eq('test.ee')
    expect(d.name_puny).to eq('test.ee')
    expect(d.name_dirty).to eq('test.ee')
  end

  it 'normalizes ns attrs' do
    d = Fabricate(:domain)
    d.nameservers.build(hostname: 'BLA.EXAMPLE.EE', ipv4: '   192.168.1.1', ipv6: '1080:0:0:0:8:800:200c:417a')
    d.save

    ns = d.nameservers.last
    expect(ns.hostname).to eq('bla.example.ee')
    expect(ns.ipv4).to eq('192.168.1.1')
    expect(ns.ipv6).to eq('1080:0:0:0:8:800:200C:417A')
  end

  it 'does not create a reserved domain' do
    Fabricate(:reserved_domain)
    expect(Fabricate.build(:domain, name: '1162.ee').valid?).to be false
  end

  it 'validates period' do
    expect(Fabricate.build(:domain, period: 0).valid?).to be false
    expect(Fabricate.build(:domain, period: 4).valid?).to be false
    expect(Fabricate.build(:domain, period: 3).valid?).to be true
  end

  it 'generates auth info' do
    d = Fabricate(:domain)
    expect(d.auth_info).to_not be_empty
  end

  it 'manages statuses automatically' do
    d = Fabricate(:domain)
    expect(d.domain_statuses.count).to eq(1)
    expect(d.domain_statuses.first.value).to eq(DomainStatus::OK)

    d.period = 2
    d.save

    d.reload

    expect(d.domain_statuses.count).to eq(1)
    expect(d.domain_statuses.first.reload.value).to eq(DomainStatus::OK)

    d.domain_statuses.build(value: DomainStatus::CLIENT_DELETE_PROHIBITED)
    d.save

    d.reload

    expect(d.domain_statuses.count).to eq(1)
    expect(d.domain_statuses.first.value).to eq(DomainStatus::CLIENT_DELETE_PROHIBITED)
  end

  with_versioning do
    context 'when not saved' do
      it 'does not create domain version' do
        Fabricate.build(:domain)
        expect(DomainVersion.count).to eq(0)
      end

      it 'does not create child versions' do
        Fabricate.build(:domain)
        expect(ContactVersion.count).to eq(0)
        expect(NameserverVersion.count).to eq(0)
      end
    end

    context 'when saved' do
      before(:each) do
        # Fabricate(:domain_validation_setting_group)
        # Fabricate(:dnskeys_setting_group)
        Fabricate(:domain)
      end

      it 'creates domain version' do
        expect(DomainVersion.count).to eq(1)
        expect(ContactVersion.count).to eq(3)
        expect(NameserverVersion.count).to eq(3)
      end
    end
  end
end