lapis-yggdrasil 0.5.0

data/spec/factories/authentication_error_factory.rb

@@ -0,0 +1,14 @@
+FactoryGirl.define do
+  factory :error, class: Lapis::Yggdrasil::AuthenticationError do
+    transient do
+      code Lapis::Yggdrasil::ErrorCodes::INVALID_CREDENTIALS
+      message 'Invalid credentials'
+    end
+
+    trait :no_message do
+      message nil
+    end
+
+    initialize_with { new(code, message) }
+  end
+end

data/spec/factories/message_factory.rb

@@ -0,0 +1,111 @@
+require 'json'
+
+FactoryGirl.define do
+  factory :profile_entry, class: Hash do
+    transient do
+      profile { build(:profile) }
+    end
+
+    initialize_with do
+      hash = {
+          :name => profile.name,
+          :id   => profile.id.to_s(false)
+      }
+      hash[:legacy] = true if profile.legacy?
+      hash
+    end
+  end
+
+  factory :message, class: HTTP::Message do
+    transient do
+      structure Hash.new
+      document { structure.to_json }
+      status 200
+    end
+
+    trait :empty do
+      document ''
+    end
+
+    initialize_with do
+      message = HTTP::Message.new_response(document)
+      message.status = status
+      message
+    end
+  end
+
+  factory :token_message, parent: :message do
+    transient do
+      access { build(:uuid) }
+      client { build(:uuid) }
+      base_structure do
+        {
+            :accessToken => access.to_s(false),
+            :clientToken => client.to_s(false)
+        }
+      end
+      structure { base_structure }
+    end
+  end
+
+  factory :error_message, parent: :message do
+    transient do
+      error 'Not Found'
+      error_message 'The server has not found anything matching the request URI'
+      cause 'Testing'
+      status 404
+      structure do
+        hash = {
+            :error => error,
+            :errorMessage => error_message
+        }
+        hash[:cause] = cause if cause
+        hash
+      end
+    end
+
+    trait :forbidden do
+      error 'ForbiddenOperationException'
+      error_message 'Invalid credentials. Invalid username or password.'
+      cause nil
+    end
+
+    trait :token do
+      error 'ForbiddenOperationException'
+      error_message 'Invalid token.'
+      cause nil
+    end
+
+    trait :profile do
+      error 'IllegalArgumentException'
+      error_message 'Access token already has a profile assigned.'
+      cause nil
+    end
+
+    trait :no_cause do
+      cause nil
+    end
+  end
+
+  factory :authentication_message, aliases: [:auth_message], parent: :token_message do
+    transient do
+      profiles { build_list(:profile, 5) }
+      selected { profiles.first }
+      structure do
+        base_structure.
+            merge(:availableProfiles => profiles.map { |profile| build(:profile_entry, :profile => profile) }).
+            merge(:selectedProfile => build(:profile_entry, :profile => selected))
+      end
+    end
+  end
+
+  factory :refresh_message, parent: :token_message do
+    transient do
+      profile { build(:profile) }
+      structure do
+        base_structure.
+            merge(:selectedProfile => build(:profile_entry, :profile => profile))
+      end
+    end
+  end
+end

data/spec/factories/profile_factory.rb

@@ -0,0 +1,20 @@
+FactoryGirl.define do
+  factory :profile, class: Lapis::Yggdrasil::Profile do
+    transient do
+      id nil
+      name 'Notch'
+      uuid { build(:uuid, :source => id) }
+      is_legacy false
+    end
+
+    trait :legacy do
+      is_legacy true
+    end
+
+    trait :modern do
+      is_legacy false
+    end
+
+    initialize_with { new(uuid, name, is_legacy) }
+  end
+end

data/spec/factories/session_info_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :session_info, aliases: [:info], class: Lapis::Yggdrasil::SessionInfo do
+    transient do
+      client_token { build(:uuid) }
+      access_token { build(:uuid) }
+      profile { build(:profile) }
+    end
+
+    initialize_with { new(client_token, access_token, profile) }
+  end
+end

data/spec/factories/uuid_factory.rb

@@ -0,0 +1,28 @@
+require 'lapis/uuid'
+
+FactoryGirl.define do
+  factory :uuid, class: Lapis::Uuid do
+    transient do
+      source nil
+    end
+
+    initialize_with do
+      case source
+        when nil
+          Lapis::Uuid.generate
+        when Lapis::Uuid
+          source
+        else
+          Lapis::Uuid.parse(source.to_s)
+      end
+    end
+  end
+
+  factory :uuid_str, class: String do
+    transient do
+      source nil
+    end
+
+    initialize_with { build(:uuid, :source => source).to_s.delete('-') }
+  end
+end

data/spec/lapis/yggdrasil/agent_spec.rb

@@ -0,0 +1,103 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Lapis::Yggdrasil::Agent do
+
+  describe '#name' do
+    let(:name) { 'Foobar' }
+    subject(:agent) { build(:agent, :name => name) }
+    subject { agent.name }
+
+    it 'is the expected value' do
+      is_expected.to eq name
+    end
+
+    it 'is frozen' do
+      is_expected.to be_frozen
+    end
+  end
+
+  describe '#version' do
+    let(:version) { 5 }
+    subject(:agent) { build(:agent, :version => version) }
+    subject { agent.version }
+
+    it 'is the expected value' do
+      is_expected.to eq version
+    end
+  end
+
+  describe '#==' do
+    subject { agent1 == agent2 }
+
+    context 'with identical agents' do
+      let(:agent1) { build(:agent) }
+      let(:agent2) { Lapis::Yggdrasil::Agent.new(agent1.name, agent1.version) }
+
+      it 'is true' do
+        is_expected.to eq true
+      end
+    end
+
+    context 'with different agents' do
+      let(:agent1) { build(:agent) }
+      let(:agent2) { Lapis::Yggdrasil::Agent.new(agent1.name + '-foobar', agent1.version) }
+
+      it 'is false' do
+        is_expected.to eq false
+      end
+    end
+  end
+
+  describe '.from_properties' do
+    let(:name) { 'Foobar' }
+    let(:version) { 5 }
+
+    context 'with all properties set' do
+      subject(:agent) { Lapis::Yggdrasil::Agent.from_properties({ :name => name, :version => version }) }
+
+      it 'sets the name' do
+        expect(agent.name).to eq name
+      end
+
+      it 'sets the version' do
+        expect(agent.version).to eq version
+      end
+    end
+
+    context 'without the name property set' do
+      let(:default_name) { Lapis::Yggdrasil::Agent::DEFAULT_AGENT.name }
+      subject(:agent) { Lapis::Yggdrasil::Agent.from_properties({ :version => version }) }
+
+      it 'uses the default name' do
+        expect(agent.name).to eq default_name
+      end
+    end
+
+    context 'without the version property set' do
+      let(:default_version) { Lapis::Yggdrasil::Agent::DEFAULT_AGENT.version }
+      subject(:agent) { Lapis::Yggdrasil::Agent.from_properties({ :name => name }) }
+
+      it 'uses the default version' do
+        expect(agent.version).to eq default_version
+      end
+    end
+
+  end
+
+  describe '::DEFAULT_AGENT' do
+    subject(:agent) { Lapis::Yggdrasil::Agent::DEFAULT_AGENT }
+
+    it 'is an Agent instance' do
+      is_expected.to be_a Lapis::Yggdrasil::Agent
+    end
+
+    it 'has "Minecraft" as the name' do
+      expect(agent.name).to eq 'Minecraft'
+    end
+
+    it 'has 1 as the version' do
+      expect(agent.version).to eq 1
+    end
+  end
+
+end

data/spec/lapis/yggdrasil/authentication_client_spec.rb

@@ -0,0 +1,200 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Lapis::Yggdrasil::AuthenticationClient do
+  let(:username) { 'Notch' }
+  let(:password) { 'qwerty' }
+  let(:bad_username) { 'N0tch' }
+  let(:bad_password) { '1337h@x0r' }
+  let(:prev_session) { build(:info) }
+  let(:bad_session) { build(:info) }
+  let(:profile) { build(:profile) }
+
+  let(:url) { 'https://example.com' }
+  subject(:client) { Lapis::Yggdrasil::AuthenticationClient.new(url) }
+
+  before(:each) do
+    stub_request(:post, url + '/authenticate').
+        with(headers: { 'Content-Type' => 'application/json' }).to_return do |request|
+      hash = JSON.parse(request.body)
+      message = if hash['username'] == username && hash['password'] == password
+                  client_token = hash.key?('clientToken') ? Lapis::Uuid.parse(hash['clientToken']) : prev_session.client_token
+                  build(:authentication_message, :access => prev_session.access_token, :client => client_token)
+                else
+                  build(:error_message, :forbidden)
+                end
+      { :body => message.body, :status => message.status, :headers => { 'Content-Type' => 'application/json' } }
+    end
+
+    stub_request(:post, url + '/refresh').
+        with(headers: { 'Content-Type' => 'application/json' }).to_return do |request|
+      hash = JSON.parse(request.body)
+      message = if prev_session.access_token == hash['accessToken'] && prev_session.client_token == hash['clientToken']
+                  if hash.key?('selectedProfile')
+                    build(:error_message, :profile)
+                  else
+                    build(:refresh_message, :client => prev_session.client_token)
+                  end
+                else
+                  build(:error_message, :token)
+                end
+      { :body => message.body, :status => message.status, :headers => { 'Content-Type' => 'application/json' } }
+    end
+
+    stub_request(:post, url + '/validate').
+        with(headers: { 'Content-Type' => 'application/json' }).to_return do |request|
+      hash = JSON.parse(request.body)
+      message = if prev_session.access_token == hash['accessToken'] && prev_session.client_token == hash['clientToken']
+                  build(:message, :empty)
+                else
+                  build(:error_message, :token)
+                end
+      { :body => message.body, :status => message.status, :headers => { 'Content-Type' => 'application/json' } }
+    end
+
+    stub_request(:post, url + '/signout').
+        with(headers: { 'Content-Type' => 'application/json' }).to_return do |request|
+      hash = JSON.parse(request.body)
+      message = if hash['username'] == username && hash['password'] == password
+                  build(:message, :empty)
+                else
+                  build(:error_message, :forbidden)
+                end
+      { :body => message.body, :status => message.status, :headers => { 'Content-Type' => 'application/json' } }
+    end
+
+    stub_request(:post, url + '/invalidate').
+        with(headers: { 'Content-Type' => 'application/json' }).to_return do |request|
+      hash = JSON.parse(request.body)
+      message = if prev_session.access_token == hash['accessToken'] && prev_session.client_token == hash['clientToken']
+                  build(:message, :empty)
+                else
+                  build(:error_message, :token)
+                end
+      { :body => message.body, :status => message.status, :headers => { 'Content-Type' => 'application/json' } }
+    end
+  end
+
+  describe '.official' do
+    subject { Lapis::Yggdrasil::AuthenticationClient.official }
+
+    it 'is an AuthenticationClient' do
+      is_expected.to be_an Lapis::Yggdrasil::AuthenticationClient
+    end
+  end
+
+  describe '#authenticate' do
+    context 'with valid credentials' do
+      subject(:session) { client.authenticate(username, password) }
+
+      it 'returns a Session' do
+        is_expected.to be_a Lapis::Yggdrasil::Session
+      end
+    end
+
+    context 'with invalid credentials' do
+      subject(:session) { client.authenticate(bad_username, bad_password) }
+
+      it 'raises an AuthenticationError' do
+        expect { subject }.to raise_error(Lapis::Yggdrasil::AuthenticationError)
+      end
+    end
+
+    context 'with a client token' do
+      let(:client_token) { build(:uuid) }
+      subject(:session) { client.authenticate(username, password, client_token) }
+
+      it 'retains the client token' do
+        expect(session.info.client_token).to eq client_token
+      end
+    end
+
+    context 'without a client token' do
+      subject(:session) { client.authenticate(username, password, nil) }
+
+      it 'gets a new client token' do
+        expect(session.info.client_token).not_to eq nil
+      end
+    end
+  end
+
+  describe '#refresh' do
+    context 'with a valid session' do
+      subject(:session) { client.refresh(prev_session) }
+
+      it 'returns updated session info' do
+        is_expected.to be_a Lapis::Yggdrasil::SessionInfo
+      end
+    end
+
+    context 'with an invalid session' do
+      subject(:session) { client.refresh(bad_session) }
+
+      it 'raises an AuthenticationError' do
+        expect { subject }.to raise_error(Lapis::Yggdrasil::AuthenticationError)
+      end
+    end
+
+    context 'with a profile' do
+      subject(:session) { client.refresh(prev_session, profile) }
+
+      it 'raises an AuthenticationError' do
+        expect { subject }.to raise_error(Lapis::Yggdrasil::AuthenticationError)
+      end
+    end
+  end
+
+  describe '#validate' do
+    context 'with a valid session' do
+      subject(:result) { client.validate(prev_session) }
+
+      it 'is true' do
+        is_expected.to eq true
+      end
+    end
+
+    context 'with an invalid session' do
+      subject(:result) { client.validate(bad_session) }
+
+      it 'is false' do
+        is_expected.to eq false
+      end
+    end
+  end
+
+  describe '#signout' do
+    context 'with valid credentials' do
+      subject { client.signout(username, password) }
+
+      it 'does not raise an error' do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context 'with invalid credentials' do
+      subject { client.signout(bad_username, bad_password) }
+
+      it 'raises an AuthenticationError' do
+        expect { subject }.to raise_error(Lapis::Yggdrasil::AuthenticationError)
+      end
+    end
+  end
+
+  describe '#invalidate' do
+    context 'with a valid session' do
+      subject { client.invalidate(prev_session) }
+
+      it 'does not raise an error' do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context 'with an invalid session' do
+      subject { client.invalidate(bad_session) }
+
+      it 'raises an AuthenticationError' do
+        expect { subject }.to raise_error(Lapis::Yggdrasil::AuthenticationError)
+      end
+    end
+  end
+
+end