bbc_redux 0.4.0.pre

data/lib/bbc/redux/serializers.rb

@@ -0,0 +1,101 @@
+require 'representable'
+require 'representable/json'
+require 'representable/json/collection'
+
+require_relative 'channel'
+
+module BBC
+  module Redux
+
+    # @private
+    module Serializers
+
+      class Asset < Representable::Decorator
+        include Representable::JSON
+
+        property :description
+        property :access_key, :as => :key
+        property :name
+        property :reference
+        property :uuid
+
+        nested :timing do
+          property :duration
+          property :start
+        end
+
+        property :channel, :class => BBC::Redux::Channel do
+          property :name
+          property :display_name
+        end
+      end
+
+      class Channel < Representable::Decorator
+        include Representable::JSON
+        property :category_id, :as => :category
+        property :display_name, :as => :longname
+        property :name
+        property :sortorder
+      end
+
+      class Channels < Representable::Decorator
+        include Representable::JSON::Collection
+        items extend: Channel, class: BBC::Redux::Channel
+      end
+
+      class ChannelCategory < Representable::Decorator
+        include Representable::JSON
+        property :description
+        property :id
+        property :priority
+      end
+
+      class ChannelCategories < Representable::Decorator
+        include Representable::JSON::Collection
+        items extend: ChannelCategory, class: BBC::Redux::ChannelCategory
+      end
+
+      class SearchResults < Representable::Decorator
+        include Representable::JSON
+        property :created_at, :as => :time
+        property :offset
+        property :query
+        property :query_time, :as => :elapsed
+        property :total,      :as => :total_found
+        property :total_returned
+
+        nested :results do
+          collection :assets, :extend => Asset, :class => BBC::Redux::Asset
+        end
+      end
+
+      class User < Representable::Decorator
+        include Representable::JSON
+
+        property :can_invite
+        property :created
+        property :id
+        property :uuid
+
+        collection :permitted_services
+
+        nested :details do
+          property :department
+          property :division
+          property :email
+          property :name
+          property :username
+        end
+
+        nested :legal do
+          property :legal_accepted, :as => :accepted
+          property :legal_html
+        end
+
+      end
+
+    end
+
+  end
+end
+

data/lib/bbc/redux/user.rb

@@ -0,0 +1,107 @@
+require 'virtus'
+
+module BBC
+  module Redux
+
+    # Redux API User Object
+    #
+    # @example Properties of the user object
+    #
+    #   user = redux_client.user
+    #
+    #   user.can_invite?  #=> Boolean
+    #   user.created      #=> DateTime
+    #   user.email        #=> String
+    #   user.first_name   #=> String
+    #   user.id           #=> Integer
+    #   user.last_name    #=> String
+    #   user.username     #=> String
+    #   user.uuid         #=> String
+    #
+    # @example Check if user can proceed or needs to sign T&C's
+    #
+    #   if user.must_sign_terms?
+    #     puts "Hey #{user.name}, you need to sign these terms"
+    #     puts user.legal_html
+    #   end
+    #
+    # @author Matt Haynes <matt.haynes@bbc.co.uk>
+    class User
+
+      include Virtus.value_object
+
+      # @!attribute [r] can_invite
+      # @return [Boolean] whether the user has ability to invite others to Redux
+      attribute :can_invite, Boolean
+
+      alias :can_invite? :can_invite
+
+      # @!attribute [r] created
+      # @return [DateTime] the date on which user account was created
+      attribute :created,  DateTime
+
+      # @!attribute [r] department
+      # @return [String] the user's organisational department
+      attribute :department, String, :default => ''
+
+      # @!attribute [r] division
+      # @return [String] the user's organisational division
+      attribute :division, String, :default => ''
+
+      # @!attribute [r] email
+      # @return [String] the user's email
+      attribute :email, String, :default => ''
+
+      # @!attribute [r] id
+      # @return [Integer] the user's id
+      attribute :id, Integer
+
+      # @!attribute [r] legal_accepted
+      # @see User#must_sign_terms?
+      # @return [String] whether the user has accepted the T&C's
+      attribute :legal_accepted, Boolean, :default => true
+
+      # @!attribute [r] legal_html
+      # @return [String] a blob of T&C's HTML that the user may need to accept
+      attribute :legal_html, String, :default => ''
+
+      # @!attribute [r] name
+      # @return [String] the user's full name
+      attribute :name, String, :default => ''
+
+      # @!attribute [r] permitted_services
+      # @return [Array<String>] a list of services user has access to
+      attribute :permitted_services, Array[String], :default => []
+
+      # @!attribute [r] username
+      # @return [String] the user's username
+      attribute :username, String, :default => ''
+
+      # @!attribute [r] uuid
+      # @return [String] the user's uuid
+      attribute :uuid, String
+
+      # @!attribute [r] first_name
+      # @return [String] the user's first name
+      def first_name
+        name.split(' ').first
+      end
+
+      # @!attribute [r] last_name
+      # @return [String] the user's last name
+      def last_name
+        name.split(' ').last
+      end
+
+      # @!attribute [r] must_sign_terms?
+      # @see User#legal_accepted
+      # @see User#legal_html
+      # @return [String] whether the user must sign some T&C's before proceeding
+      def must_sign_terms?
+        !legal_accepted
+      end
+
+    end
+
+  end
+end

data/lib/bbc/redux/version.rb

@@ -0,0 +1,8 @@
+module BBC
+  module Redux
+
+    # Library version
+    VERSION = '0.4.0.pre'
+
+  end
+end

data/lib/bbc/redux.rb

@@ -0,0 +1,10 @@
+require_relative 'redux/asset'
+require_relative 'redux/channel'
+require_relative 'redux/channel_category'
+require_relative 'redux/client'
+require_relative 'redux/end_points'
+require_relative 'redux/key'
+require_relative 'redux/media_url'
+require_relative 'redux/search_results'
+require_relative 'redux/serializers'
+require_relative 'redux/user'

data/spec/bbc/redux/asset_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe BBC::Redux::Asset do
+
+  let(:json)   { read_fixture 'asset.json'         }
+
+  let(:asset)  { described_class.new               }
+
+  let(:mapper) { BBC::Redux::Serializers::Asset    }
+
+  subject      { mapper.new(asset).from_json(json) }
+
+  {
+
+    # attribute            => expected_value
+    'channel.class'        => BBC::Redux::Channel,
+    'channel.display_name' => 'CBeebies',
+    'channel.name'         => 'cbeebies',
+    :access_key            => '1-1397227462-ba632af7af1ad',
+    :description           => 'Animated adventures of Pingu. [S]',
+    :disk_reference        => '5966413090093319525',
+    :duration              => 300,
+    :key                   => BBC::Redux::Key.new('1-1397227462-ba632af7af1ad'),
+    :name                  => 'Pingu',
+    :reference             => '5966413090093319525',
+    :start                 => DateTime.parse('2014-01-08 06:50:00 +0000'),
+    :title                 => 'Pingu',
+    :uuid                  => '26a141fc-8511-4fef-aa2b-af1d1de5a75a',
+
+  }.each_pair do |attribute, value|
+    its(attribute) { should eq(value) }
+  end
+
+  BBC::Redux::MediaUrl::TEMPLATES.each do |type|
+    describe "##{type}_url" do
+      it 'returns url of the correct type using the asset reference and key' do
+        url = subject.send(:"#{type}_url")
+        expect(url.type).to eq(type)
+        expect(url.identifier).to eq(subject.reference)
+        expect(url.key).to eq(subject.key)
+      end
+    end
+  end
+
+end

data/spec/bbc/redux/channel_category_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe BBC::Redux::ChannelCategory do
+
+  let(:json)   { read_fixture 'channel_categories.json'      }
+
+  let(:mapper) { BBC::Redux::Serializers::ChannelCategories  }
+
+  subject      { mapper.new([]).from_json(json)              }
+
+  {
+
+    # attr / method     => expected_value
+    'size'              => 5,
+    'first.description' => 'BBC TV',
+    'first.id'          => 1,
+    'first.priority'    => 1000,
+
+  }.each_pair do |attribute, value|
+    its(attribute) { should eq(value) }
+  end
+
+end

data/spec/bbc/redux/channel_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe BBC::Redux::Channel do
+
+  let(:json)   { read_fixture 'channels.json'      }
+
+  let(:mapper) { BBC::Redux::Serializers::Channels }
+
+  subject      { mapper.new([]).from_json(json)    }
+
+  {
+
+    # attr / method => expected_value
+    'size'               => 8,
+    'first.name'         => 'bbcone',
+    'first.display_name' => 'BBC One',
+    'first.category_id'  => 1,
+    'first.sort_order'   => 1010,
+
+  }.each_pair do |attribute, value|
+    its(attribute) { should eq(value) }
+  end
+
+end

data/spec/bbc/redux/client_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+describe BBC::Redux::Client do
+
+  let(:http_client) { double('http_client')                     }
+  let(:token)       { 'SOME-TOKEN'                              }
+  let(:instance)    {
+    described_class.new(:token => token, :http => http_client)
+  }
+
+  shared_examples_for 'a json based http method' do
+    let(:unknown_response)  { double('http_resp', :code => rand(200..399)) }
+
+    let(:badjson_exception) { BBC::Redux::Client::JsonParseException         }
+    let(:badjson_response)  { double('http_resp', :code => 200, :body => '') }
+
+    let(:fivexx_exception) { BBC::Redux::Client::HttpException            }
+    let(:fivexx_response)  { double('http_resp', :code => rand(500..505)) }
+
+    let(:forbidden_exception) { BBC::Redux::Client::ForbiddenException }
+    let(:forbidden_response)  { double('http_resp', :code => 403)      }
+
+    it 'should raise forbidden exception when HTTP API returns 403' do
+      expect(http_client).to receive(:post).and_return(forbidden_response)
+      expect { subject }.to raise_exception(forbidden_exception)
+    end
+
+    it 'should raise and http exception when HTTP API returns 5XX' do
+      expect(http_client).to receive(:post).and_return(fivexx_response)
+      expect { subject }.to raise_exception(fivexx_exception)
+    end
+
+    it 'should raise a generic exception with an unknown http status' do
+      expect(http_client).to receive(:post).and_return(unknown_response)
+      expect { subject }.to raise_exception
+    end
+
+    it 'should raise a json parse error when backend returns junk' do
+      expect(http_client).to receive(:post).and_return(badjson_response)
+      expect { subject }.to raise_exception(badjson_exception)
+    end
+  end
+
+  context 'initialized with username / password' do
+    subject { described_class.new({
+      :http => http_client, :username => 'foo', :password => 'bar'
+    }) }
+
+    it_behaves_like 'a json based http method'
+
+    it 'connects to redux api to get token' do
+      resp = double(:resp, :code => 200, :body => '{"token":"TOKEN"}')
+
+      expect(http_client).to \
+        receive(:post).with('https://i.bbcredux.com/user/login', {
+        :body           => {
+          :username => 'foo',
+          :password => 'bar',
+          :token    => nil,
+        },
+        :followlocation => true
+      }).and_return(resp)
+
+      expect(subject.token).to eq("TOKEN")
+    end
+  end
+
+  context 'initialized with token' do
+    it 'should be ready to go' do
+      expect(instance.token).to eq(token)
+      expect(instance.http).to eq(http_client)
+    end
+  end
+
+  context 'initialized with neither token or username / password' do
+    it 'raises an error' do
+      expect { described_class.new }.to raise_error
+    end
+  end
+
+  describe '#asset' do
+    subject { instance.asset(reference) }
+
+    let(:resp)        {
+      double(:http_resp, :code => 200, :body => read_fixture('asset.json'))
+    }
+
+    let(:reference)   { '5966413090093319525'                     }
+    let(:uuid)        { '26a141fc-8511-4fef-aa2b-af1d1de5a75a'    }
+
+    it_behaves_like 'a json based http method'
+
+    it 'takes json from the backend HTTP API and generates an asset object' do
+      expect(http_client).to \
+        receive(:post).with('https://i.bbcredux.com/asset/details', {
+          :body           => { :reference => reference, :token => token },
+          :followlocation => true,
+        }).and_return(resp)
+
+      expect(subject.class).to eq(BBC::Redux::Asset)
+      expect(subject.name).to eq('Pingu')
+      expect(subject.channel.name).to eq('cbeebies')
+    end
+
+    it 'works when given a UUID rather than a disk reference' do
+      expect(http_client).to \
+        receive(:post).with('https://i.bbcredux.com/asset/details', {
+          :body           => { :uuid => uuid, :token => token },
+          :followlocation => true,
+        }).and_return(resp)
+
+      asset = instance.asset(uuid)
+
+      expect(asset.class).to eq(BBC::Redux::Asset)
+      expect(asset.name).to eq('Pingu')
+      expect(asset.channel.name).to eq('cbeebies')
+    end
+  end
+
+  describe '#channels' do
+    subject { instance.channels }
+
+    let(:resp)        {
+      double(:http_resp, :code => 200, :body => read_fixture('channels.json'))
+    }
+
+    it_behaves_like 'a json based http method'
+
+    it 'takes json from the backend HTTP API and generates list of channels' do
+      expect(http_client).to \
+        receive(:post).with('https://i.bbcredux.com/asset/channel/available', {
+          :body           => { :token => token },
+          :followlocation => true,
+        }).and_return(resp)
+
+      expect(subject.size).to eq(8)
+      expect(subject.first.class).to eq(BBC::Redux::Channel)
+      expect(subject.first.name).to eq('bbcone')
+    end
+
+  end
+
+  describe '#channel_categories' do
+    subject { instance.channel_categories }
+
+    let(:resp)        {
+      double(:http_resp, :code => 200,
+        :body => read_fixture('channel_categories.json')) }
+
+    it_behaves_like 'a json based http method'
+
+    it 'takes json from the backend HTTP API, generates list of categories' do
+      expect(http_client).to \
+        receive(:post).with('https://i.bbcredux.com/asset/channel/categories', {
+          :body           => { :token => token },
+          :followlocation => true,
+        }).and_return(resp)
+
+      expect(subject.size).to eq(5)
+      expect(subject.first.class).to eq(BBC::Redux::ChannelCategory)
+      expect(subject.first.description).to eq('BBC TV')
+    end
+
+  end
+
+  describe '#logout' do
+    subject { instance.logout }
+
+    let(:resp) { double(:http_resp, :code => 200, :body => '{}') }
+
+    it_behaves_like 'a json based http method'
+
+    it 'posts to logout endpoint' do
+      expect(http_client).to \
+        receive(:post).with('https://i.bbcredux.com/user/logout', {
+          :body           => { :token => token },
+          :followlocation => true,
+        }).and_return(resp)
+
+      expect(subject).to eq(nil)
+    end
+
+  end
+
+  describe '#search' do
+    subject { instance.search }
+
+    let(:resp)        {
+      double(:resp, :code => 200, :body => read_fixture('search_results.json'))
+    }
+    it_behaves_like 'a json based http method'
+
+    it 'passes params to backend HTTP API and generates results object' do
+      expect(http_client).to \
+        receive(:post).with('https://i.bbcredux.com/asset/search', {
+          :body           => { :q => 'foo', :longer => '200', :token => token },
+          :followlocation => true,
+        }).and_return(resp)
+
+      results = instance.search(:q => 'foo', :longer => 200)
+
+      expect(results.class).to be(BBC::Redux::SearchResults)
+      expect(results.query).to eq(:q => 'foo', :longer => 200)
+    end
+
+    context 'channel object based parameters' do
+
+      let(:bbcone) { BBC::Redux::Channel.new(:name => 'bbcone') }
+
+      it 'formats them correctly' do
+        expect(http_client).to \
+          receive(:post).with('https://i.bbcredux.com/asset/search', {
+            :body           => { :channel => 'bbcone', :token => token },
+            :followlocation => true,
+          }).and_return(resp)
+
+        results = instance.search(:channel => bbcone)
+
+        expect(results.class).to be(BBC::Redux::SearchResults)
+      end
+
+      it 'handles an array correctly' do
+        url = 'https://i.bbcredux.com/asset/search?channel=bbcone&channel=bbctwo'
+
+        expect(http_client).to \
+          receive(:post).with(url, {
+            :body           => { :token => token },
+            :followlocation => true,
+          }).and_return(resp)
+
+        results = instance.search(:channel => [ bbcone, 'bbctwo' ])
+
+        expect(results.class).to be(BBC::Redux::SearchResults)
+      end
+    end
+
+    context 'date / time based parameters' do
+      it 'formats them correctly' do
+        [ Time.now, Date.today, DateTime.now ].each do |datey|
+          formatted = datey.strftime('%Y-%m-%dT%H:%M:%S')
+
+          expect(http_client).to \
+            receive(:post).with('https://i.bbcredux.com/asset/search', {
+              :body           => { :date => formatted, :token => token },
+              :followlocation => true,
+            }).and_return(resp)
+
+          results = instance.search(:date => datey)
+
+          expect(results.class).to be(BBC::Redux::SearchResults)
+        end
+      end
+    end
+
+  end
+
+  describe '#user' do
+    subject { instance.user }
+
+    let(:resp)        {
+      double(:http_resp, :code => 200, :body => read_fixture('user.json'))
+    }
+
+    it_behaves_like 'a json based http method'
+
+    it 'takes json from the backend HTTP API and generates a user object' do
+      expect(http_client).to \
+        receive(:post).with('https://i.bbcredux.com/user/details', {
+          :body           => { :token => token },
+          :followlocation => true,
+        }).and_return(resp)
+
+      expect(subject.class).to eq(BBC::Redux::User)
+      expect(subject.name).to eq('Jane Smith')
+    end
+
+  end
+
+end

data/spec/bbc/redux/key_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe BBC::Redux::Key do
+
+  let(:value)  { '1-1397227462-ba632af7af1adb6f96dbeceb83331ad6' }
+
+  subject      { described_class.new(value)                      }
+
+  {
+
+    # attr/method => expected_value
+    :value        => '1-1397227462-ba632af7af1adb6f96dbeceb83331ad6',
+    :to_s         => '1-1397227462-ba632af7af1adb6f96dbeceb83331ad6',
+    :expires_at   => DateTime.parse('2014-04-11 15:44:22 +0100'),
+
+  }.each_pair do |attribute, value|
+    its(attribute) { should eq(value) }
+  end
+
+  describe '#expired?' do
+    it 'should be true when expires_at is in the past' do
+      expect(generate_key(Time.now - 300).expired?).to be(true)
+    end
+
+    it 'should be false when expires_at is in the future' do
+      expect(generate_key(Time.now + 300).expired?).to be(false)
+    end
+  end
+
+  describe '#live?' do
+    it 'should be false when expires_at is in the past' do
+      expect(generate_key(Time.now - 300).live?).to be(false)
+    end
+
+    it 'should be true when expires_at is in the future' do
+      expect(generate_key(Time.now + 300).live?).to be(true)
+    end
+  end
+
+  describe '#ttl' do
+    it 'should return the key\'s TLL in seconds' do
+      expect(generate_key.ttl).to be_within(1).of(0)
+    end
+  end
+
+  describe '#==' do
+    it 'should be true if keys have same values' do
+      expect(subject).to eq(described_class.new(value))
+    end
+
+    it 'should be false if keys have different values' do
+      expect(subject).to_not eq(generate_key)
+    end
+
+    it 'should be false if other key is something else' do
+      expect(subject).to_not eq(:something_else)
+    end
+  end
+
+  private
+
+  def generate_key(expires_at = Time.now)
+    described_class.new "1-#{expires_at.to_i}-ba632af7af1adb6f96dbeceb83331ad6"
+  end
+
+end