adcloud 0.7.0

data/lib/adcloud/topic.rb

@@ -0,0 +1,19 @@
+module Adcloud
+  class Topic < Entity
+    attribute :id, Integer
+    attribute :start_prio, Integer
+    attribute :modified, DateTime
+    attribute :created, DateTime
+    attribute :discounts, Hash
+    attribute :names, Hash
+
+    def discounts=(data)
+      @discounts = data.reduce({}) do |hash, raw_discount|
+        discount = TopicDiscount.new(raw_discount)
+        hash[discount.country_code] = discount
+        hash
+      end
+    end
+
+  end
+end

data/lib/adcloud/topic_discount.rb

@@ -0,0 +1,16 @@
+module Adcloud
+  class TopicDiscount
+    include Virtus
+
+    attribute :country_id, Integer
+    attribute :country_code, String
+    attribute :discount, Float
+    attribute :reach, Float
+    attribute :min_price_cpc, Float
+    attribute :price_cpc, Float
+    attribute :max_price_cpc, Float
+    attribute :min_price_cpm, Float
+    attribute :price_cpm, Float
+    attribute :max_price_cpm, Float
+  end
+end

data/lib/adcloud/version.rb

@@ -0,0 +1,3 @@
+module Adcloud
+  VERSION = '0.7.0'
+end

data/lib/adcloud/webhook.rb

@@ -0,0 +1,35 @@
+module Adcloud
+  class Webhook
+    ALL = [:on_topic_price_update, :on_campaign_update]
+
+    attr_accessor :events
+
+    # @param events [Array<Hash>, String] Events
+    def initialize(events)
+      self.events = events.kind_of?(Array) ? events : JSON.parse(events.to_s)
+    rescue
+      raise ArgumentError.new("Invalid webhook event data!")
+    end
+
+    def events=(events)
+      @events = [events].flatten.map { |event| Adcloud::WebhookEvent.new(event) }
+      if Adcloud.config.webhooks.filter_tests
+        @events.reject! { |event| event.test_data? }
+      end
+    end
+
+    def process!
+      self.events.each do |event|
+        proc = case event.type
+        when 'TopicPrice.update'
+          :on_topic_price_update
+        when 'Booking.update'
+          :on_campaign_update
+        else
+          :on_unknown_webhook
+        end
+        Adcloud.config.webhooks.send(proc).call(event)
+      end
+    end
+  end
+end

data/lib/adcloud/webhook_config.rb

@@ -0,0 +1,18 @@
+module Adcloud
+  class WebhookConfig < ActiveSupport::Configurable::Configuration
+    def initialize
+      Adcloud::Webhook::ALL.each do |hook|
+        self.send("#{hook}=", WebhookConfig.method(:unused_webhook))
+      end
+      self.on_unknown_webhook = WebhookConfig.method(:unknown_webhook)
+    end
+
+    def self.unused_webhook(event)
+      Adcloud.logger.warn { "Webhook behaviour missing for #{event.inspect}" }
+    end
+
+    def self.unknown_webhook(event)
+      Adcloud.logger.warn { "Unknown webhook event #{event.inspect}. Please contact gem maintainer!" }
+    end
+  end
+end

data/lib/adcloud/webhook_event.rb

@@ -0,0 +1,18 @@
+module Adcloud
+  class WebhookEvent
+    attr_reader :data, :meta
+
+    def initialize(raw_response)
+      @meta = raw_response.delete('_meta') || {}
+      @data = raw_response || {}
+    end
+
+    def type
+      @meta['event']
+    end
+
+    def test_data?
+      @meta.has_key?('is_test_data') && @meta['is_test_data']
+    end
+  end
+end

data/test/adcloud/advertisement_test.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+describe Adcloud::Advertisement do
+
+  it 'should set the correct api endpoint' do
+    Adcloud::Advertisement.api_endpoint.must_equal 'advertisements'
+  end
+
+  # for more tests checkout entity tests
+end

data/test/adcloud/authentication_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+describe Adcloud::Authentication do
+
+  describe "initialization" do
+
+    describe "with a valid hash" do
+      before do
+        @adcloud_auth = Adcloud::Authentication.new(:client_id => "0987654321", :client_secret => "1234567890")
+      end
+
+      it "should have a client_id 0987654321" do
+        @adcloud_auth.client_id.must_equal "0987654321"
+      end
+
+      it "should have a client_secret 1234567890" do
+        @adcloud_auth.client_secret.must_equal "1234567890"
+      end
+
+    end
+
+    describe "with an empty hash" do
+
+      before do
+        @adcloud_auth = Adcloud::Authentication.new({})
+      end
+
+      it "should have a client_id and client_secret being nil" do
+        @adcloud_auth.client_secret.must_be_nil
+        @adcloud_auth.client_id.must_be_nil
+      end
+
+    end
+
+  end
+
+  describe "is successful" do
+
+    it "should return a token" do
+      stub_request(:post, "https://api.adcloud.com:443/v2/oauth/access_token").with(:body => {"client_id"=>"0987654321", "client_secret"=>"1234567890", "grant_type"=>"none"}, :headers => {'Accept'=>'*/*', 'Content-Type'=>'application/x-www-form-urlencoded', 'User-Agent'=>'Ruby'}).to_return(:status => 200, :body => {"_meta" => {"access_token" => "bab0e5c477f211c4612345678907498b6e55600"}, "access_token" => "bab0e5c477f211c4612345678907498b6e55600","scope" => ""}, :headers => {})
+      adcloud_auth = Adcloud::Authentication.new(:client_id => "0987654321", :client_secret => "1234567890")
+      adcloud_auth.authenticate!
+      adcloud_auth.token.must_equal "bab0e5c477f211c4612345678907498b6e55600"
+    end
+
+  end
+
+  # describe "is unsuccessful" do
+
+  #   it "should raise an authentication error" do
+  #     stub_request(:post, "https://api.adcloud.com:443/v2/oauth/access_token").with(:body => {"client_id"=>"0987654321", "client_secret"=>"1234567890", "grant_type"=>"none"}, :headers => {'Accept'=>'*/*', 'Content-Type'=>'application/x-www-form-urlencoded', 'User-Agent'=>'Ruby'}).to_return(:status => 401, :body => {"status" => 401, "errors" => [{"message" => "Bad credentials"}]}, :headers => {})
+  #     adcloud_auth = Adcloud::Authentication.new(:client_id => "0987654321", :client_secret => "1234567890")
+  #     -> { adcloud_auth.authenticate! }.must_raise(Adcloud::AuthenticationError)
+  #   end
+
+  # end
+
+end

data/test/adcloud/campaign_test.rb

@@ -0,0 +1,54 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+describe Adcloud::Campaign do
+  subject { Adcloud::Campaign }
+
+  let(:campaign) { subject.new }
+  let(:connection) { stub() }
+
+  before do
+    subject.stubs(:connection => connection)
+  end
+
+  describe "validate" do
+    let(:request_attributes) { campaign.attributes.select { |k, v| ![:_meta, :id].include?(k) } }
+
+    it 'should validate against the api' do
+      connection.expects(:get).with('campaigns/validate', { campaign: request_attributes }).returns({'_meta' => { 'status' => 226, 'details' => {}}})
+      campaign.validate
+    end
+
+    it 'should populate the errors hash' do
+      response_data = {'_meta' => { 'status' => 226, 'details' => { 'company_id' => ['must be present'] } } }
+      connection.stubs(:get).returns(response_data)
+      campaign.validate
+      campaign.errors['company_id'].must_equal ['must be present']
+    end
+
+    it 'raises an exception when the response is not well formatted' do
+      connection.expects(:get).with('campaigns/validate', { campaign: request_attributes })
+      -> { campaign.validate }.must_raise(Adcloud::AdcloudSucks::InvalidApiResponse)
+    end
+  end
+
+  describe '#valid?' do
+    it 'validates the model' do
+      campaign.expects(:validate)
+      campaign.valid?
+    end
+
+    it 'returns true when object is valid' do
+      campaign.stubs(:validate)
+      campaign.errors = {}
+      campaign.valid?.must_equal true
+    end
+
+    it 'returns false when the object is invalid' do
+      campaign.stubs(:validate)
+      campaign.errors = { company_id: ['must be present'] }
+      campaign.valid?.must_equal false
+    end
+  end
+
+end

data/test/adcloud/connection_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+describe Adcloud::Connection do
+
+  subject { Adcloud::Connection.new }
+
+  let(:authentication) { stub(:authenticate! => true, :token => "0987654321") }
+
+  describe "url" do
+  
+    it "should be https://api.adcloud.com:443/" do
+      subject.url.must_equal "https://api.adcloud.com:443/v2/"
+    end
+  
+  end
+
+  describe "authentication token" do
+  
+    it "should be 0987654321" do
+      subject.expects(:authentication).returns(authentication)
+      subject.authentication_token.must_equal "0987654321"
+    end
+  
+  end
+
+  describe "authentication" do
+    it "should return an authentication object" do
+      Adcloud::Authentication.expects(:new).returns(authentication)
+      subject.authentication.must_equal authentication
+    end
+  end
+
+  describe "an authenticated connection" do
+    let(:url) { "https://api.adcloud.com:443/v2/whatever" }
+
+    before do
+      subject.stubs(:authentication_token).returns("0987654321")
+    end
+    
+    describe "post" do
+
+      it "should fire a post request" do
+        stub_request(:post, url).to_return(:status => 200, :body => {"_meta" => {}, "hello" => "world"}, :headers => {})
+        subject.post('whatever').must_equal({"_meta" => {}, "hello" => "world" })
+      end
+
+      # it "should raise an InvalidRequest Exception" do
+      #   stub_request(:post, url).to_return(:status => 500, :body => "{}", :headers => {})
+      #   -> { subject.post('whatever') }.must_raise(Adcloud::InvalidRequest)
+      # end
+
+    end
+
+    describe "get" do
+
+      it "should fire a get request" do
+        stub_request(:get, url).to_return(:status => 200, :body => {"_meta" => {}, "hello" => "world"}, :headers => {})
+        subject.get('whatever').must_equal({"_meta" => {}, "hello" => "world" })
+      end
+
+      # it "should raise an InvalidFilter Exception" do
+      #   stub_request(:get, url).to_return(:status => 400, :body => "{}", :headers => {})
+      #   -> { subject.get('whatever') }.must_raise(Adcloud::InvalidFilter)
+      # end
+
+      # it "should raise a NotFound Exception" do
+      #   stub_request(:get, url).to_return(:status => 404, :body => "{}", :headers => {})
+      #   -> { subject.get('whatever') }.must_raise(Adcloud::NotFound)
+      # end
+
+      # it "should raise an InvalidRequest Exception" do
+      #   stub_request(:get, url).to_return(:status => 500, :body => "{}", :headers => {})
+      #   -> { subject.get('whatever') }.must_raise(Adcloud::InvalidRequest)
+      # end
+
+    end
+  end
+end

data/test/adcloud/customer_test.rb

@@ -0,0 +1,6 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+describe Adcloud::Customer do
+  # check the entity test
+end

data/test/adcloud/entity_test.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+require 'test_helper'
+
+describe Adcloud::Entity do
+
+  class Car < Adcloud::Entity
+    #self.api_endpoint = 'cars'
+    attribute :id, Integer
+    attribute :name, String
+  end
+
+  subject { Car }
+
+  let(:connection) { stub }
+
+  describe ".connection" do
+    it "should return a connection object" do
+      Adcloud::Connection.expects(:new).returns(connection)
+      subject.connection.must_equal(connection)
+    end
+  end
+
+
+  describe "#connection" do
+    it "should return the class level connection object" do
+      subject.expects(:connection).returns(connection)
+      subject.new.connection.must_equal(connection)
+    end
+  end
+
+  describe '.api_endpoint' do
+    it 'its api endpoint is cars' do
+      subject.api_endpoint.must_equal 'cars'
+    end
+  end
+
+  describe "find" do
+    let(:response_data) { { 'id' => 42, 'name' => 'Porsche' } }
+
+    it "should return a car" do
+      subject.connection.expects(:get).with('cars/42').returns(response_data)
+      subject.find(42).must_be_instance_of(Car)
+    end
+  end
+
+  describe "all" do
+    let(:empty_response_data) { {"_meta"=>{"type"=>"Array<>", "page"=>1, "size"=>0, "per_page"=>50, "total_count"=>0, "total_pages"=>0, "sort"=>{}, "uuid"=>"aabe4f5f31691f049ea1942e6a6d1793"}, "items"=>[]} }
+    let(:response_data) { { "_meta" => { "type" => "Array<Car>", "page" => 1, "size" => 2, "per_page" => 50, "total_count" => 2, "total_pages" => 1, "sort" => {}, "uuid" => "aabe4f5f31691f049ea1942e6a6d1793" }, "items" => [{ "id" => 52654, "name" => 'Mercedes', "_meta" => { "type" => "Car" } }, { "id" => 52655, "name" => 'Audi', "_meta" => { "type" => "Car" } }]} }
+
+    it "should return an empty array if response is empty" do
+      subject.connection.expects(:get).with('cars', :filter => {}, :page => 1, :per_page => 50).returns(empty_response_data)
+      subject.all.must_be_instance_of(Array)
+    end
+
+    it 'should return an array if response contains objects' do
+      subject.connection.expects(:get).with('cars', :filter => {}, :page => 1, :per_page => 50).returns(response_data)
+      subject.all.must_be_instance_of(Array)
+    end
+
+    it 'should return an array of cars' do
+      subject.connection.expects(:get).with('cars', :filter => {}, :page => 1, :per_page => 50).returns(response_data)
+      subject.all.each { |item| item.must_be_instance_of(subject) }
+    end
+
+    it 'should return 2 cars' do
+      subject.connection.expects(:get).with('cars', :filter => {}, :page => 1, :per_page => 50).returns(response_data)
+      subject.all.size.must_equal 2
+    end
+
+    it 'should pass the filter param' do
+      subject.connection.expects(:get).with('cars', :filter => { :oliver => "ist chef" }, :page => 1, :per_page => 50).returns(response_data)
+      subject.all(:oliver => "ist chef")
+    end
+  end
+
+  describe '#create' do
+    before { subject.stubs(:connection => connection) }
+
+    describe 'when submitting a valid object' do
+      let(:response) { { '_meta' => { 'status' => 200 }, 'id' => 1 } }
+
+      it 'sends a request to the api' do
+        car = subject.new
+        attributes = car.attributes
+        attributes.delete(:id)
+        attributes.delete(:_meta)
+        connection.expects(:post).with('cars', { 'car' => attributes }).returns(response)
+        car.create
+      end
+
+      it 'sets the car id' do
+        connection.stubs(:post).returns(response)
+        car = subject.new
+        car.create
+        car.id.must_equal 1
+      end
+
+      it 'returns true' do
+        connection.stubs(:post).returns(response)
+        subject.new.create.must_equal true
+      end
+    end
+
+    describe 'when submitting an invalid car' do
+      let(:error) { Adcloud::BadRequestError.new(stub(:body => {'_meta' => { 'details' => { :name => ['cannot be empty'] }}})) }
+      before do
+        subject.stubs(:connection => connection)
+        connection.stubs(:post).raises(error)
+      end
+
+      it 'returns false' do
+        subject.new.create.must_equal false
+      end
+
+      it 'sets the errors hash' do
+        car = subject.new
+        car.create
+        car.errors.must_equal({ :name => ['cannot be empty'] })
+      end
+    end
+  end
+
+  describe '.create' do
+    it 'creates a new car' do
+      car = subject.new
+      subject.expects(:new).returns(car)
+      car.expects(:create)
+      subject.create.must_equal car
+    end
+  end
+
+  describe "errors" do
+    it "should be empty" do
+      subject.new.errors.must_be_empty
+    end
+  end
+
+  describe '.api_name' do
+    it 'returns the class name in lowercase' do
+      Car.api_name.must_equal 'car'
+    end
+
+    it 'removes the namespace' do
+      module MyTest
+        class Truck < Adcloud::Entity
+        end
+      end
+      MyTest::Truck.api_name.must_equal 'truck'
+    end
+
+    it 'transforms camel case to underscore' do
+      class AirPlane < Adcloud::Entity
+      end
+      AirPlane.api_name.must_equal 'air_plane'
+    end
+
+  end
+
+end