adyen-admin 0.0.2 → 0.0.3

data/CHANGES.md

@@ -2,12 +2,18 @@
 
 ## vx.x.x - ???
   * update Docu
-  * metafile
-  * parent
-  * build binaries
+  * parse metafile
+  * parent (instead of base)
+  * add CLI binaries (to compile + upload) -> read from .adyenrc file
   * make compatible with Live system
 
-## v0.0.2 - ???
+## v0.0.2
+  * force update remote
+  * .all unions remote + local (no more duplicates)
+  * freeze locals to indicate missing remote endpoint
+  * raise exception when page could not be loaded
+
+## v0.0.2
  * cleanup
  * dep. fix
 

data/README.md

@@ -21,7 +21,7 @@ require 'adyen/admin'
 
 Adyen::Admin.login(<accountname>, <username>, <password>)
 
-Adyen::Admin::Skin.all  #returns all remote skins
+Adyen::Admin::Skin.all  #returns all remote + local skins
 
 ```
 

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/adyen-admin.rb

@@ -1,4 +1,5 @@
 # Copyright (c) 2012, SoundCloud Ltd., Tobias Bielohlawek
+
 require 'adyen-admin/client'
 require 'adyen-admin/skin'
 
@@ -6,6 +7,8 @@ module Adyen
   module Admin
     extend Adyen::Admin::Client
 
+    class AuthenticationError < StandardError; end
+
     def skin_dir
       "."
     end

data/lib/adyen-admin/client.rb

@@ -7,6 +7,7 @@ module Adyen
       DASHBOARD   = "https://ca-test.adyen.com/ca/ca/overview/default.shtml"
 
       def login(accountname, username, password)
+        @authenticated = false
         page = Adyen::Admin.client.get(LOGIN)
         page = Adyen::Admin.client.submit(page.form.tap do |form|
           form.j_account  = accountname
@@ -14,12 +15,22 @@ module Adyen
           form.j_password = password
         end)
         raise "Wrong username + password combination" if page.uri.to_s != DASHBOARD
+        @authenticated = true
+      end
+
+      def get(url)
+        client.get(url).tap do |page|
+          raise AuthenticationError unless page.uri.to_s.include?(url)
+        end
       end
 
       def client
         @agent ||= Mechanize.new
       end
 
+      def authenticated?
+        @authenticated
+      end
     end
   end
 end

data/lib/adyen-admin/skin.rb

@@ -13,27 +13,35 @@ module Adyen
       PUBLISH      = "https://ca-test.adyen.com/ca/ca/skin/publishskin.shtml?skinCode=%s"
       SKINS        = "https://ca-test.adyen.com/ca/ca/skin/skins.shtml"
 
-      attr_accessor :code, :name, :path
+      attr_reader :code, :name, :path
 
       def initialize(attributes = {})
         attributes.each do |key, value|
           send("#{key}=", value)
         end
 
-        if !path && code
-          path = skin_path([code,name].join("-"))
-        end
+        path ||= File.join(Adyen::Admin.skin_dir, [code,name].compact.join("-"))
 
         raise ArgumentError unless code
       end
 
+      # union remote and local skins. Local skins are frozen to
+      # indicate no availble remote counter part which avoid update
       def self.all(path = nil)
-        all_remote + all_local(path)
+        {}.tap do |hash|
+          self.all_remote.each do |skin|
+            hash[skin.code] = skin unless hash[skin.code]
+          end
+          self.all_local(path).each do |skin|
+            hash[skin.code] = skin.freeze unless hash[skin.code]
+          end
+        end.values
       end
 
+      # fetch all remote skins
       def self.all_remote
         @@skins_remote ||= begin
-          page = Adyen::Admin.client.get(SKINS)
+          page = Adyen::Admin.get(SKINS)
           page.search(".data tbody tr").map do |node|
             Skin.new({
               :code => node.search("a")[0].content.strip,
@@ -43,45 +51,54 @@ module Adyen
         end
       end
 
+      # fetch all local skins
       def self.all_local(path)
         Dir[File.join(path.to_s, "*")].map do |path|
           Skin.new(:path => path) rescue nil
         end.compact
       end
 
+      # find a skin within remote + local ones
       def self.find(skin_code)
-        all.select do |skin|
+        self.all.select do |skin|
           skin.code == skin_code
         end.first
       end
 
+      def self.purge_cache
+        @@skins_remote = nil
+      end
+
       ##################################
+
       def path=(path)
         if Skin.is_skin_path?(path)
-          code, name = File.basename(path).split("-").reverse
-          self.code ||= code
-          self.name ||= name
-          raise ArgumentError if code && self.code != code
+          new_code, new_name = File.basename(path).split("-").reverse
+          self.code ||= new_code
+          self.name ||= new_name
+          raise ArgumentError if self.code && self.code != new_code
           @path = path
         end
       end
 
+      ##################################
+
       def version(scope = :local)
         case scope
         when :test
-          page = Adyen::Admin.client.get(VERSION_TEST % code)
+          page = Adyen::Admin.get(VERSION_TEST % code)
           page.search("body p").first.content.scan(/Version:(\d+)/).flatten.first.to_i
         when :live
-          page = Adyen::Admin.client.get(VERSION_LIVE % code)
+          page = Adyen::Admin.get(VERSION_LIVE % code)
           page.search("body p").first.content.scan(/Version:(\d+)/).flatten.first.to_i
         else
-          page = Adyen::Admin.client.get(TEST % code)
+          page = Adyen::Admin.get(TEST % code)
           page.search(".data tr td")[2].content.to_i
         end
       end
 
       def test_url(options = {})
-        page = Adyen::Admin.client.get(TEST % code)
+        page = Adyen::Admin.get(TEST % code)
         page = Adyen::Admin.client.submit(page.form.tap do |form|
           #:amount => 199, :currency => :shopper_locale, :country_code, :merchant_reference, :merchant_account, :system, :skip, :one_page
         end)
@@ -120,25 +137,28 @@ module Adyen
               zipfile.add(file.sub(path, code), file)
             end
 
-            if dir = skin_path("base")
-              Dir["#{dir}/**/**"].each do |file|
-                begin
-                  next if file.include?(".yml")
-                  next if file.include?(".erb")
-                  zipfile.add(file.sub(dir, code), file)
-                rescue Zip::ZipEntryExistsError
-                  # NOOP
-                end
+            dir = File.join(File.dirname(path), parent_skin_code)
+            Dir["#{dir}/**/**"].each do |file|
+              begin
+                next if file.include?(".yml")
+                next if file.include?(".erb")
+                zipfile.add(file.sub(dir, code), file)
+              rescue Zip::ZipEntryExistsError
+                # NOOP
               end
             end
           end
         end
       end
 
+      def parent_skin_code
+        "base"
+      end
+
       # http://stackoverflow.com/questions/3420587/ruby-mechanize-multipart-form-with-file-upload-to-a-mediawiki
       def upload
         file = self.compile
-        page = Adyen::Admin.client.get(UPLOAD % code)
+        page = Adyen::Admin.get(UPLOAD % code)
         page = Adyen::Admin.client.submit(page.form.tap do |form|
           form.file_uploads.first.file_name = file
         end)
@@ -149,25 +169,30 @@ module Adyen
       def publish
         raise ArgumentError unless code
 
-        page = Adyen::Admin.client.get(PUBLISH % code)
+        page = Adyen::Admin.get(PUBLISH % code)
         page = Adyen::Admin.client.submit(page.form.tap do |form|
         end)
       end
 
       #################################
 
-      def skin_path(skin_code)
-        skin_dir = path ? File.dirname(path) : Adyen::Admin.skin_dir
-        File.join(skin_dir, skin_code).tap do |path|
-          return nil unless File.directory?(path)
-        end
+      def to_s
+        self.code
       end
 
       def ==(skin)
         self.code == skin.code
       end
 
-      private
+      protected
+      def code=(c)
+        @code = c
+      end
+
+      def name=(n)
+        @name = n
+      end
+
       def self.is_skin_path?(path)
         %w(skin.html.erb inc css js).each do |sub_path|
           return true if File.exists?(File.join(path, sub_path))

data/spec/adyen-admin/client_spec.rb

@@ -5,6 +5,10 @@ require "adyen-admin/client"
 describe Adyen::Admin::Client, :vcr  do
   let(:login) { Adyen::Admin.login("SoundCloud", "skinadmin", "12312311") }
 
+  before do
+    Adyen::Admin.client.cookie_jar.clear!
+  end
+
   describe "#login" do
     it 'passes with correct username + password' do
       expect do
@@ -18,4 +22,12 @@ describe Adyen::Admin::Client, :vcr  do
       end
     end
   end
+
+  describe "#get" do
+    it 'raises authenticated error when not logged in' do
+      expect do
+        Adyen::Admin.get(Adyen::Admin::Skin::SKINS)
+      end.to raise_error Adyen::Admin::AuthenticationError
+    end
+  end
 end

data/spec/adyen-admin/skin_spec.rb

@@ -9,166 +9,191 @@ module Adyen::Admin
     let(:skin_code) { "7hFAQnmt" }
     let(:skin) { Skin.new(:code => skin_code, :name => "example") }
 
-    before(:all) do
-      VCR.use_cassette("login") do
-        Adyen::Admin.login("SoundCloud", "skinadmin", "12312311")
+    context "authenticated" do
+      before(:all) do
+        VCR.use_cassette("login") do
+          Adyen::Admin.client.cookie_jar.clear!
+          Adyen::Admin.login("SoundCloud", "skinadmin", "12312311")
+        end
       end
-    end
 
-    describe ".all" do
-      it 'returns the skins' do
-        Skin.all.should == [
-          skin,
-          Skin.new(:code => "Kx9axnRf", :name => "demo")
-        ]
+      before do
+        Adyen::Admin::Skin.purge_cache
       end
-    end
 
-    describe ".all_local" do
-      it 'returns the skins' do
-        Skin.all_local(skin_fixtures).should == [
-          Skin.new(:code => "base"),
-          Skin.new(:code => "DV3tf95f"),
-          skin,
-          Skin.new(:code => "JH0815"),
-        ]
+      describe ".all_remote" do
+        it 'returns the skins' do
+          Skin.all.should == [
+            skin,
+            Skin.new(:code => "Kx9axnRf", :name => "demo"),
+            Skin.new(:code => "vQW0fEo8", :name => "test"),
+          ]
+        end
       end
-    end
 
-    describe ".find" do
-      it 'returns the skin' do
-        Skin.find(skin_code).should == skin
+      describe ".all_local" do
+        it 'returns the skins' do
+          Skin.all_local(skin_fixtures).should == [
+            Skin.new(:code => "base"),
+            Skin.new(:code => "DV3tf95f"),
+            skin,
+            Skin.new(:code => "JH0815"),
+          ]
+        end
       end
 
-      it 'returns no skin' do
-        Skin.find("dummy code").should == nil
+      describe ".all" do
+        it 'returns the skins' do
+          Skin.all(skin_fixtures).should == [
+            skin,
+            Skin.new(:code => "Kx9axnRf", :name => "demo"),
+            Skin.new(:code => "vQW0fEo8", :name => "test"),
+            Skin.new(:code => "base"),
+            Skin.new(:code => "DV3tf95f"),
+            Skin.new(:code => "JH0815")
+          ]
+        end
+
+        it 'freezes local skins' do
+          Skin.all(skin_fixtures).last.should be_frozen
+        end
       end
-    end
 
-    describe "#new" do
-      let(:path) { "#{skin_fixtures}/example-7hFAQnmt" }
 
-      it "sets code attribute" do
-        Skin.new(:code => skin_code).code.should == skin_code
-      end
+      describe ".find" do
+        it 'returns the skin' do
+          Skin.find(skin_code).should == skin
+        end
 
-      it "sets name attribute" do
-        Skin.new(:code => skin_code, :name => "name").name.should == "name"
+        it 'returns no skin' do
+          Skin.find("dummy code").should == nil
+        end
       end
 
-      it "sets path attribute" do
-        Skin.new(:path => path).path.should == path
-      end
+      describe "#new" do
+        let(:path) { "#{skin_fixtures}/example-7hFAQnmt" }
 
-      it "auto sets code from path" do
-        Skin.new(:path => path).code.should == "7hFAQnmt"
-      end
+        it "sets code attribute" do
+          Skin.new(:code => skin_code).code.should == skin_code
+        end
 
-      it "raises error on wrong code for path" do
-        expect do
-          Skin.new(:code => "different", :path => path).path.should == path
-        end.to raise_error
-      end
+        it "sets name attribute" do
+          Skin.new(:code => skin_code, :name => "name").name.should == "name"
+        end
 
-      it "raises error on empty code" do
-        expect do
-          Skin.new
-        end.to raise_error
-      end
-    end
+        it "sets path attribute" do
+          Skin.new(:path => path).path.should == path
+        end
 
-    describe "#download"  do
-      let(:zip_filename) { "#{skin.code}.zip"}
-      after do
-        `rm -rf #{zip_filename}`
-      end
+        it "auto sets code from path" do
+          Skin.new(:path => path).code.should == "7hFAQnmt"
+        end
 
-      it "gets the file" do
-        skin.download
-        File.should be_exists(zip_filename)
+        it "raises error on wrong code for path" do
+          expect do
+            Skin.new(:code => "different", :path => path).path.should == path
+          end.to raise_error
+        end
+
+        it "raises error on empty code" do
+          expect do
+            Skin.new
+          end.to raise_error
+        end
       end
-    end
 
-    describe "#compile" do
-      let(:skin_code) { "DV3tf95f" }
-      let(:skin) { Skin.new(:path => "#{skin_fixtures}/#{skin_code}") }
+      describe "#download"  do
+        let(:zip_filename) { "#{skin.code}.zip"}
+        after do
+          `rm -rf #{zip_filename}`
+        end
 
-      def zip_contains(zip_filename, file)
-        Zip::ZipFile.open(zip_filename, 'r') do |zipfile|
-          return true if zipfile.find_entry(File.join(skin_code, file))
+        it "gets the file" do
+          skin.download
+          File.should be_exists(zip_filename)
         end
-        false
       end
 
-      context "without base" do
-        before do
-          `mv #{skin_fixtures}/base #{skin_fixtures}/base2`
+      describe "#compile" do
+        let(:skin_code) { "DV3tf95f" }
+        let(:skin) { Skin.new(:path => "#{skin_fixtures}/#{skin_code}") }
+
+        def zip_contains(zip_filename, file)
+          Zip::ZipFile.open(zip_filename, 'r') do |zipfile|
+            return true if zipfile.find_entry(File.join(skin_code, file))
+          end
+          false
         end
 
-        after do
-          `mv #{skin_fixtures}/base2 #{skin_fixtures}/base`
+        context "without base" do
+          before do
+            `mv #{skin_fixtures}/base #{skin_fixtures}/base2`
+          end
+
+          after do
+            `mv #{skin_fixtures}/base2 #{skin_fixtures}/base`
+          end
+
+          it "includes screen file" do
+            zip_contains(skin.compile, "css/screen.css").should be_true
+          end
+
+          it "excludes print files" do
+            zip_contains(skin.compile, "css/print.css").should_not be_true
+          end
         end
 
         it "includes screen file" do
           zip_contains(skin.compile, "css/screen.css").should be_true
         end
 
-        it "excludes print files" do
-          zip_contains(skin.compile, "css/print.css").should_not be_true
+        it "includes print file" do
+          zip_contains(skin.compile, "css/print.css").should be_true
         end
-      end
-
-      it "includes screen file" do
-        zip_contains(skin.compile, "css/screen.css").should be_true
-      end
 
-      it "includes print file" do
-        zip_contains(skin.compile, "css/print.css").should be_true
-      end
-
-      it "excludes meta file" do
-        zip_contains(skin.compile, "metadata.yml").should_not be_true
-      end
+        it "excludes meta file" do
+          zip_contains(skin.compile, "metadata.yml").should_not be_true
+        end
 
-      it "excludes skin file" do
-        zip_contains(skin.compile, "skin.html.erb").should_not be_true
+        it "excludes skin file" do
+          zip_contains(skin.compile, "skin.html.erb").should_not be_true
+        end
       end
-    end
 
-    describe "#upload" do
-      context "valid set" do
-        it "increases version" do
-          skin.path = "#{skin_fixtures}/example-7hFAQnmt"
+      describe "#upload" do
+        context "valid set" do
+          it "increases version" do
+            skin.path = "#{skin_fixtures}/example-7hFAQnmt"
 
-          expect do
-            skin.upload
-          end.to change { skin.version }.by(1)
+            expect do
+              skin.upload
+            end.to change { skin.version }.by(1)
+          end
         end
       end
-    end
 
-    describe "#version" do
-      let(:skin) { Skin.new(:code => "Kx9axnRf", :name => "demo") }
+      describe "#version" do
+        let(:skin) { Skin.new(:code => "Kx9axnRf", :name => "demo") }
 
-      it "returns uploaded value" do
-        skin.version.should == 2
-      end
+        it "returns uploaded value" do
+          skin.version.should == 14
+        end
 
-      it "returns test value" do
-        skin.version(:test).should == 2
-      end
+        it "returns test value" do
+          skin.version(:test).should == 14
+        end
 
-      it "returns live value" do
-        skin.version(:live).should == 0
+        it "returns live value" do
+          skin.version(:live).should == 0
+        end
       end
-    end
 
-    describe "#test_url" do
-      it "returns url to test" do
-        skin.test_url.to_s.should include("https://test.adyen.com/hpp/select.shtml")
+      describe "#test_url" do
+        it "returns url to test" do
+          skin.test_url.to_s.should include("https://test.adyen.com/hpp/select.shtml")
+        end
+        #todo test with options
       end
-      #todo test with options
     end
-
   end
 end