vtools 0.0.1

data/spec/options_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "options"
+
+describe VTools::Options do
+
+  # hooks
+  before :all do
+    
+  end
+
+  # around to test inside the methods
+
+  before do
+    
+  end
+
+  after do
+    
+  end
+
+  after :all do
+    
+  end
+
+  # specs
+  context "#parse!" do
+
+    it "creates valid options" do
+      opts =    ["server_commnad", "-option_one", "--", "-app_option", "-app_option_two",]
+      opts_v =  opts.dup << "-v"
+      opts_h =  opts_v.dup << "-h"
+
+      @test = nil
+      OptionParser.stub!(:new).and_return nil
+
+      VTools::Options.stub!(:argv=).and_return do |arr|
+        arr.should_not include ["server_commnad", "-option_one", "--"]
+        arr.should include ["-app_option", "-app_option_two"]
+      end
+
+      VTools::Options.parse! opts
+
+      VTools::Options.stub!(:argv=).and_return { |arr| arr.should == ["-v"] }
+      VTools::Options.parse! opts_v
+
+      VTools::Options.stub!(:argv=).and_return { |arr| arr.should == ["-h"] }
+      VTools::Options.parse! opts_h
+    end
+
+  end
+
+end

data/spec/shared_methods_spec.rb

@@ -0,0 +1,351 @@
+require "spec_helper"
+require "shared_methods"
+
+describe VTools::SharedMethods do
+
+  class Tested
+  end
+
+  # hooks
+  before do
+    @class = Tested.new
+  end
+
+  # specs
+  context "::Common" do
+
+    class Tested
+      include VTools::SharedMethods::Common
+
+      def initialize
+        @@logger = nil
+      end
+
+      def test_logger
+        @@logger
+      end
+    end
+
+    # hooks
+    before do
+      @class = Tested.new
+    end
+
+    context "#logger=" do
+
+      it "appends logger" do
+        @class.logger = "test.logger"
+        @class.test_logger.should == "test.logger"
+      end
+    end
+
+    context "#log" do
+
+      let(:tester) { double(nil) }
+
+      def stub_methods
+        tester.stub(:level=).and_return nil
+        Logger.stub!(:new).and_return { tester }
+      end
+
+      before do
+        VTools::CONFIG[:logging] = nil
+      end
+
+      it "skips log (logging disable)" do
+        tester.stub(:send).and_return nil
+
+        @class.logger = tester
+        tester.should_not_receive :send
+        
+        @class.log :test, "test"
+      end
+
+      it "creates logger and send message" do
+        VTools::CONFIG[:logging] = true
+
+        stub_methods
+        Logger::INFO = "test.level"
+
+        Logger.should_receive(:new).with(STDOUT, 1000, 1024000).once
+        tester.should_receive(:level=).with("test.level").once
+        tester.should_receive(:send).with(:test_level, "test.log").once
+
+        @class.log :test_level, "test.log"
+      end
+
+      it "creates valid log message to existing logger" do
+        VTools::CONFIG[:logging] = true
+
+        stub_methods
+
+        Logger.should_not_receive(:new)
+        tester.should_not_receive(:level=)
+        tester.should_receive(:send).with(:test_level, "test.log").once
+
+        @class.logger = tester
+        @class.log :test_level, "test.log"
+      end
+    end
+
+    context "#json_to_obj" do
+
+      it "calls valid chain" do
+        @class.stub(:parse_json).and_return { |jstr| "parsed.#{jstr}" }
+        @class.stub(:hash_to_obj).and_return { |js| "hashed.#{js}" }
+
+        @class.json_to_obj("JSON").should == "hashed.parsed.JSON"
+      end
+    end
+
+    context "#hash_to_obj" do
+
+      it "calls exception" do
+        OpenStruct.stub!(:new).and_return { raise "test exception" }
+        expect { @class.hash_to_obj "test" }.to raise_error VTools::ConfigError, "Can't convert setup to object"
+      end
+      it "accepts hash" do
+        OpenStruct.stub!(:new).and_return "hash accepted"
+        expect { @class.hash_to_obj(:test_key => "test.value").should == "hash accepted" }.to_not raise_error
+      end
+    end
+
+    context "#parse_json" do
+
+      it "raises exception on invalid json" do
+        JSON.stub!(:parse).and_return { raise "test.execption" }
+        expect { @class.parse_json("invalid json") }.to raise_error VTools::ConfigError, "Invalid JSON"
+      end
+
+      it "parses json" do
+        JSON.stub!(:parse).and_return "JSON.parsed"
+        expect { @class.parse_json("valid json").should == "JSON.parsed" }.to_not raise_error
+      end
+    end
+
+    context "#keys_to_sym" do
+
+      it "fails execution on non Hash" do
+        @class.keys_to_sym("non Hash").should == "non Hash"
+      end
+
+      it "converts string keys to symbols" do
+        @class.keys_to_sym(:key => "one", "other_key" => "two").should == { :key => "one", :other_key => "two" }
+      end
+    end
+
+    context "#config" do
+
+      it "returns config index" do
+        VTools::CONFIG[:test_index] = "test.value"
+
+        @class.config(:test_index).should == "test.value"
+        @class.config(:nonexistent_index).should be nil
+      end
+    end
+
+    context "#network_call" do
+
+      let(:sock) { double nil }
+      let(:tcp_request) { "GET / HTTP/1.0\r\n\r\n" }
+      
+      def validate_request body
+        sock.should_receive(:print).with( tcp_request ).once
+        sock.should_receive(:read).once.and_return "headers\r\n\r\n#{body}"
+        sock.should_receive(:close).once
+      end
+
+      it "creates tcp request with default settings" do
+
+        TCPSocket.should_receive(:open).with("localhost", 80).once.and_return {sock}
+        validate_request "body"
+        expect do
+          @class.network_call("tcp://localhost").should == "body"
+        end.to_not raise_error
+      end
+
+      it "creates tcp request" do
+        tcp_request["/"] = "/test/address"
+
+        TCPSocket.should_receive(:open).with("server.com", 8080).once.and_return {sock}
+        validate_request "test body"
+        expect do
+          @class.network_call("http://server.com:8080/test/address").should == "test body"
+        end.to_not raise_error
+      end
+
+      it "fails tcp request" do
+
+        TCPSocket.should_receive(:open).once.and_return { raise "test exception" }
+        @class.should_receive(:log).once.and_return {|l| l.should == :error}
+        expect { @class.network_call("") }.to_not raise_error
+      end
+    end
+
+    context "#generate_path" do
+
+      it "returns valid string" do
+        VTools::CONFIG[:video_storage] = "test/path/"
+        VTools::CONFIG[:thumb_storage] = "/thumb/path"
+
+        @class.generate_path("test.filename").should == "test/path"
+        @class.generate_path("test.filename", "thumb").should == "/thumb/path"
+
+        VTools::CONFIG[:thumb_storage] = ''
+
+        VTools::CONFIG[:PWD] = "test/pwd"
+        @class.generate_path("test.filename", "thumb").should == "test/pwd"
+
+        VTools::CONFIG[:PWD] = nil
+        VTools::CONFIG[:thumb_storage] = nil
+
+        @class.generate_path("test.filename", "thumb").should == ""
+      end
+
+      it "executes block" do
+        prc = proc do |file|
+          file.should == "test.filename"
+          self.class.should == Tested
+          "test/path"
+        end
+
+        VTools::CONFIG[:video_storage] = prc
+        @class.generate_path("test.filename", "video").should == "test/path"
+      end
+    end
+
+    context "#path_generator" do
+
+      before do
+        VTools::CONFIG[:video_storage] = nil
+        VTools::CONFIG[:thumb_storage] = nil
+      end
+
+      let(:block) { proc { nil } }
+
+      it "appends generator to thumbs" do
+        @class.path_generator "thumb", &block
+        VTools::CONFIG[:thumb_storage].should == block
+      end
+
+      it "appends generator to thumbs (invalid placeholedr given)" do
+        @class.path_generator "invalid", &block
+        VTools::CONFIG[:thumb_storage].should == block
+        VTools::CONFIG[:video_storage].should be nil
+      end
+
+      it "appends generator to video" do
+        @class.path_generator "video", &block
+        VTools::CONFIG[:video_storage].should == block
+        VTools::CONFIG[:thumb_storage].should be nil
+      end
+
+      it "appends generator to both (default)" do
+        @class.path_generator &block
+        VTools::CONFIG[:video_storage].should == block
+        VTools::CONFIG[:thumb_storage].should == block
+      end
+
+      it "skips generator appending" do
+        @class.path_generator
+        VTools::CONFIG[:video_storage].should be nil
+        VTools::CONFIG[:thumb_storage].should be nil
+      end
+    end
+
+    context "#fix_encoding" do
+      
+      it "fixes encoding" do
+        path = "#{File.realpath(File.dirname(__FILE__))}/fixtures/outputs/"
+        source = File.open("#{path}file_with_iso-8859-1.txt", "r").read
+        @class.fix_encoding(source).encoding.to_s.should match(/iso-8859-1/i)
+      end
+    end
+  end # ::Common
+
+  context "::Static" do
+
+    class Tested
+      include VTools::SharedMethods::Static
+    end
+
+    # hooks
+    before do
+      @class = Tested.new
+    end
+
+    context "#load_libs" do
+
+      # CONFIG[:library]
+      # require lib
+      # rescue LoadError => e
+      #      print "Library file could not be found (#{lib})\n"
+      #    rescue SyntaxError => e
+      #      print "Library may contain non ascii characters (#{lib}).\n\n" +
+      #        "Try to set file encoding to 'binary'.\n\n"
+      #    end
+      before do
+        VTools::CONFIG[:library] = []
+      end
+
+      it "requires libraries" do
+        libs = ["one", "two", "three"]
+        VTools::CONFIG[:library] = libs
+
+        libs.each do |lib|
+          @class.should_receive(:require).with(lib)
+        end
+
+        @class.load_libs
+      end
+
+      it "raises not found error" do
+        VTools::CONFIG[:library] << "one"
+
+        @class.stub(:require).and_return { raise LoadError }
+        @class.should_receive(:print).with("Library file could not be found (one)\n")
+        @class.load_libs
+      end
+
+      it "raises syntax error" do
+        VTools::CONFIG[:library] << "one"
+
+        @class.stub(:require).and_return { raise SyntaxError }
+        @class.should_receive(:print).with("Library may contain non ascii characters (one).\n\nTry to set file encoding to 'binary'.\n\n")
+        @class.load_libs
+      end
+    end
+  end
+
+  context "::Instance" do
+  end
+
+  context "#included" do
+    it "appends methods correctly" do
+      class Tested
+        include VTools::SharedMethods
+      end
+
+      class CommonTest
+        include VTools::SharedMethods::Common
+      end
+
+      class StaticTest
+        include VTools::SharedMethods::Static
+      end
+
+      class InstanceTest
+        include VTools::SharedMethods::Instance
+      end
+
+      (CommonTest.methods + StaticTest.methods - Object.methods).each do |m|
+        Tested.should respond_to m
+      end
+
+      @tested = Tested.new
+      (CommonTest.methods + InstanceTest.methods - Object.methods).each do |m|
+        @tested.should respond_to m
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# -*- encoding: binary -*-
+ 
+["..", "../../lib", "../../lib/vtools"].each do |path|
+  dir = File.expand_path(path, __FILE__)
+  $:.unshift dir if dir and not $:.include?(dir)
+end
+
+require "vtools"
+require "rspec"
+require "stringio"
+
+# helpers utilities
+#
+module Helpers
+
+end
+
+RSpec.configure do |c|
+  c.include Helpers
+end

data/spec/storage_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+require "storage"
+
+describe VTools::Storage do
+
+  # hooks
+  before do
+    VTools::Storage.instance_variable_set(:@actions, {})
+  end
+
+  # specs
+  let(:block) { proc {} }
+
+  def valid_call method
+    VTools::Storage.instance_variable_set( :@actions, { method.to_sym => block } )
+    block.should_receive(:call)
+    expect { VTools::Storage.method(method.to_sym).call }.to_not raise_error
+  end
+
+  def validate_exception method
+    VTools::Storage.should_receive(:fails).with(method.to_sym).and_return { raise "test.error" }
+    expect { VTools::Storage.method(method.to_sym).call }.to raise_error
+  end
+
+  context "#connect" do
+
+    it "calls connect" do
+      valid_call "connect"
+    end
+
+    it "raises exception" do
+      validate_exception "connect"
+    end
+  end
+
+  context "#recv" do
+
+    it "calls recv" do
+      valid_call "recv"
+    end
+
+    it "raises exception" do
+      validate_exception "recv"
+    end
+  end
+
+  context "#send" do
+
+    it "calls send" do
+      VTools::Storage.instance_variable_set( :@actions, :send => block )
+      block.should_receive(:call).with("test.data")
+      expect { VTools::Storage.send("test.data") }.to_not raise_error
+    end
+
+    it "raises exception" do
+      VTools::Storage.should_receive(:fails).with(:send).and_return { raise "test.error" }
+      expect { VTools::Storage.send("data") }.to raise_error("test.error")
+    end
+  end
+
+  def valid_connector scope
+    VTools::Storage.method(scope.to_sym).call &block
+    scope["_action"] = ""
+    VTools::Storage.instance_variable_get(:@actions).should == { scope.to_sym => block }
+  end
+
+  context "#connect_action" do
+
+    it "connects proc" do
+      valid_connector "connect_action"
+    end
+  end
+
+  context "#recv_action" do
+
+    it "connects proc" do
+      valid_connector "recv_action"
+    end
+  end
+
+  context "#send_action" do
+
+    it "connects proc" do
+      valid_connector "send_action"
+    end
+  end
+
+  context "#setup" do
+
+    it "executes valid scope" do
+      VTools::Storage.should_receive(:instance_eval).once
+
+      VTools::Storage.setup do
+        self.should be_kind_of(VTools::Storage)
+      end
+    end
+  end
+
+  context "#fails" do
+    it "raises error with valid message" do
+      expect do
+        VTools::Storage.method(:fails).call("test_method") 
+      end.to raise_error NotImplementedError, "VTools::Storage#test_method_action must be set"
+    end
+  end
+end