taas 0.1.0

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "test-unit"
+  gem "mocha"
+  gem "shoulda"
+  gem "rack-test"
+  gem "jeweler"
+  gem "pry"
+  gem "pry-nav"
+end
+
+gem "rake"
+gem "sinatra"
+gem "json"
+

data/Gemfile.lock

@@ -0,0 +1,63 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    coderay (1.0.7)
+    git (1.2.5)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.5)
+    metaclass (0.0.1)
+    method_source (0.7.1)
+    mocha (0.11.4)
+      metaclass (~> 0.0.1)
+    multi_json (1.3.6)
+    pry (0.9.9.6)
+      coderay (~> 1.0.5)
+      method_source (~> 0.7.1)
+      slop (>= 2.4.4, < 3)
+    pry-nav (0.2.1)
+      pry (~> 0.9.9)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    shoulda (3.3.1)
+      shoulda-context (~> 1.0)
+      shoulda-matchers (~> 1.4.1)
+    shoulda-context (1.0.1)
+    shoulda-matchers (1.4.1)
+      activesupport (>= 3.0.0)
+    sinatra (1.3.3)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    slop (2.4.4)
+    test-unit (2.4.9)
+    tilt (1.3.3)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  jeweler
+  json
+  mocha
+  pry
+  pry-nav
+  rack-test
+  rake
+  shoulda
+  sinatra
+  test-unit

data/LICENSE.txt

@@ -0,0 +1,13 @@
+ Copyright 2012 Anand Bagmar (abagmar@gmail.com). 
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.rdoc

@@ -0,0 +1,27 @@
+= TaaS
+
+Typically in organizations, there are multiple projects / products. Organizations like to have a common Test Automation
+solution across these products in an effort to standardize the framework.
+
+However, this is not a good idea!
+
+Each product should be tested using the tools and technologies that are <b>"right"</b> for it.
+
+Yet - these different products talk to each other and you need a way to test the integration between them in an automated fashion.
+
+<b>"TaaS"</b> is a product that allows you to validate the integration across a variety of products via Test Automation - the <b>"correct"</b> way.
+
+= Documentation
+
+Check the doc[https://github.com/anandbagmar/taas/tree/master/doc] folder for information about TaaS and how to use it.
+
+== Copyright
+
+/**
+ * Created by: Anand Bagmar
+ * Email: abagmar@gmail.com
+ *
+ * Copyright 2010 Anand Bagmar.  Distributed under the Apache 2.0 License
+ *
+ * See LICENSE.txt for further details.
+**/

data/Rakefile

@@ -0,0 +1,27 @@
+$PROJECT_ROOT=File.expand_path(File.dirname(__FILE__))
+
+namespace :test do
+  desc "run all unit test"
+  task :unit do
+    Dir['test/**/*_test.rb'].each { |testCase|
+      tName = File.join($PROJECT_ROOT, testCase)
+      puts "running test: #{tName}"
+      load tName
+    }
+  end
+end
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name              = "taas"
+  gem.homepage          = "http://github.com/anandbagmar/taas"
+  gem.license           = "Apache 2.0"
+  gem.summary           = %q{TaaS}
+  gem.description       = %q{"TaaS" allows you to validate the integration across a variety of products via Test Automation - the "correct" way. TaaS uses a web service interface to run your end-2-end integration tests between two independent but related system. See the blog for more details: http://goo.gl/nVShb}
+  gem.authors           = ["Anand Bagmar, Akash Mishra"]
+  gem.email             = ["abagmar@gmail.com, akash.mishra20@gmail.com"]
+  gem.files.exclude "doc/**/*"
+  gem.rubyforge_project = "taas"
+end
+Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/helper/command_executer.rb

@@ -0,0 +1,9 @@
+module TaaS
+  class CommandExecuter
+    def self.execute_command(dir, command)
+      return nil if command.nil? || dir.nil? || command.empty? || dir.empty?
+      Dir.chdir(dir)
+      `#{command}`
+    end
+  end
+end

data/lib/helper/contract.rb

@@ -0,0 +1,22 @@
+module TaaS
+  class Contract
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def value_of(key)
+      @hash[key]
+    end
+
+    def has_property?(key)
+      @hash.has_key?(key)
+    end
+
+    def command(params)
+      command = @hash["command"]
+      parameter_string = ParameterFactory.generate_parameter_string(@hash["input_param_format"],params)
+      command.scan(/<taas_params>/).empty? ? command+parameter_string : command.gsub("<taas_params>",parameter_string)
+    end
+  end
+end

data/lib/helper/contracts.rb

@@ -0,0 +1,35 @@
+require 'pry'
+module TaaS
+  class Contracts
+
+    @@contract_hash = {}
+
+    def self.load(absolute_path)
+      raise "File path cant be nil or empty" if (absolute_path.nil? || absolute_path.empty?)
+      @@contract_hash = YAML.load_file(absolute_path)["contracts"] rescue {}
+    end
+
+    def self.is_empty?
+      @@contract_hash.eql?({}) || @@contract_hash.nil?
+    end
+
+    def self.contains?(contract_name)
+      @@contract_hash.keys.include?(contract_name)
+    end
+
+    def self.get_contract(contract_name)
+      return nil unless contains?(contract_name)
+      contract = Contract.new @@contract_hash[contract_name]
+      contract
+    end
+
+    def self.get_execution_attribute(attribute, contract_name)
+      return nil if @@contract_hash.nil? || @@contract_hash.eql?({})
+      @@contract_hash["contracts"][contract_name.to_s][attribute]
+    end
+
+    def self.get_all_contracts
+      return @@contract_hash
+    end
+  end
+end

data/lib/helper/output_parser.rb

@@ -0,0 +1,21 @@
+require "json"
+module TaaS
+  class OutputParser
+    def self.parse_taas_output(output)
+      output.scan(/<TaaS Response Start>(.*)<TaaS Response Complete>/m).first.first rescue nil
+    end
+
+    def self.parse_server_output(response_body)
+      return nil unless valid_server_response?(response_body)
+      body = response_body.scan(/<Taas-Output>(.*)<\/TaaS-Output>/m).first.first
+      response_json = response_body.scan(/<TaaS-Json>(.*)<\/TaaS-Json>/m).first.first
+      response_hash = JSON.parse(response_json) rescue nil
+      return nil if response_hash.nil?
+      return response_hash,body
+    end
+
+    def self.valid_server_response?(response)
+      !(response.scan(/<Taas-Output>(.*)<\/TaaS-Output>/m).empty? || response.scan(/<TaaS-Json>(.*)<\/TaaS-Json>/m).empty?)
+    end
+  end
+end

data/lib/helper/parameter_factory.rb

@@ -0,0 +1,12 @@
+module TaaS
+  class ParameterFactory
+    def self.generate_parameter_string(template,params_hash)
+      parameter_string = ""
+      template = "key=value" if template.nil?
+      params_hash.each do |key,value|
+         parameter_string += " #{template.gsub("key",key.to_s).gsub("value",value.to_s)}"
+      end
+      parameter_string
+    end
+  end
+end

data/lib/server.rb

@@ -0,0 +1,41 @@
+require "sinatra"
+
+
+Dir.glob(File.join("#{$PROJECT_ROOT}", "lib","helper", "**", "*.rb")).each do |test_file|
+  puts "requiring #{test_file}"
+  require "#{test_file}"
+end
+
+include TaaS
+
+Contracts.load(ARGV[0])
+
+post "/contract" do
+  response_json = '{"pass":"false","data":{}}'
+  output = "Contract Name is either nil or not valid."
+  if !params["contract_name"].nil? && !Contracts.is_empty? && Contracts.contains?(params["contract_name"])
+    command = Contracts.get_contract(params["contract_name"]).command(params)
+    dir = Contracts.get_contract(params["contract_name"]).value_of("dir")
+    output = CommandExecuter.execute_command(dir,command)
+    response_json = OutputParser.parse_taas_output(output)
+  end
+   "<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output><TaaS-Json>#{response_json}</TaaS-Json></TaaS-Server-Response>"
+end
+
+
+get "/" do
+  table_header ="<table width=\"600\" border=\"1\"><tr><th>Contract Name</th><th>Contract parameters</th></tr>"
+  table_footer="</table>"
+  table_body =""
+  Contracts.get_all_contracts.each_pair do |key,value|
+    inner_table_body=""
+    inner_table_header ="<table width=\"400\" border=\"1\"><tr><th>KEY</th><th>VALUE</th></tr>"
+    inner_table_footer="</table>"
+    value.each_pair do |key1,value1|
+      inner_table_body = inner_table_body + "<tr><td>#{key1}</td><td>#{value1}</td></tr>"
+    end
+    inner_table = inner_table_header+inner_table_body+inner_table_footer
+    table_body = table_body + "<tr><td>#{key}</td><td>#{inner_table}</td></tr>"
+   end
+   table_header+table_body+table_footer
+end

data/lib/taas.rb

@@ -0,0 +1,13 @@
+
+require "taas_client"
+require File.join($PROJECT_ROOT,"lib","helper","command_executer")
+
+module TaaS
+    def self.start_server(contract_file)
+      CommandExecuter.execute_command(File.dirname(__FILE__),"ruby server.rb #{contract_file}")
+    end
+
+    def self.client(url, timeout)
+      TaaSClient.new(url, timeout)
+    end
+end

data/lib/taas/version.rb

@@ -0,0 +1,3 @@
+module TaaS
+  VERSION = "0.0.1"
+end

data/lib/taas_client.rb

@@ -0,0 +1,40 @@
+require "rubygems"
+require 'uri'
+require 'net/http'
+require "json"
+require File.join($PROJECT_ROOT,"lib","helper","output_parser")
+
+module TaaS
+  class TaaSClient
+
+    attr_accessor :url, :timeout
+
+    def initialize(url, timeout_in_seconds=1000)
+      @url = url
+      @timeout = timeout_in_seconds * 10000
+    end
+
+    def execute_contract(params={})
+      response_body = request_taas_server(params)
+
+      raise "TaaS Request is false" unless OutputParser.valid_server_response?(response_body)
+
+      OutputParser.parse_server_output(response_body)
+    end
+
+
+
+    def request_taas_server(params)
+      uri = URI.parse(@url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.set_form_data(params)
+      http.read_timeout = @timeout
+      http.request(request).body
+    end
+  end
+end
+
+
+

data/taas.gemspec

@@ -0,0 +1,91 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "taas"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Anand Bagmar, Akash Mishra"]
+  s.date = "2013-04-03"
+  s.description = "\"TaaS\" allows you to validate the integration across a variety of products via Test Automation - the \"correct\" way. TaaS uses a web service interface to run your end-2-end integration tests between two independent but related system. See the blog for more details: http://goo.gl/nVShb"
+  s.email = ["abagmar@gmail.com, akash.mishra20@gmail.com"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/helper/command_executer.rb",
+    "lib/helper/contract.rb",
+    "lib/helper/contracts.rb",
+    "lib/helper/output_parser.rb",
+    "lib/helper/parameter_factory.rb",
+    "lib/server.rb",
+    "lib/taas.rb",
+    "lib/taas/version.rb",
+    "lib/taas_client.rb",
+    "taas.gemspec",
+    "test/helper/command_executer_test.rb",
+    "test/helper/contract_test.rb",
+    "test/helper/contracts_test.rb",
+    "test/helper/output_parser_test.rb",
+    "test/helper/parameter_factory_test.rb",
+    "test/server_test.rb",
+    "test/taas_client_test.rb",
+    "test/test_helper.rb"
+  ]
+  s.homepage = "http://github.com/anandbagmar/taas"
+  s.licenses = ["Apache 2.0"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "taas"
+  s.rubygems_version = "1.8.24"
+  s.summary = "TaaS"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_runtime_dependency(%q<sinatra>, [">= 0"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_development_dependency(%q<test-unit>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rack-test>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
+      s.add_development_dependency(%q<pry-nav>, [">= 0"])
+    else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<sinatra>, [">= 0"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<test-unit>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rack-test>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<pry-nav>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<sinatra>, [">= 0"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<test-unit>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rack-test>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<pry-nav>, [">= 0"])
+  end
+end
+

data/test/helper/command_executer_test.rb

@@ -0,0 +1,21 @@
+require File.join($PROJECT_ROOT, 'lib', 'helper', 'command_executer')
+require File.join($PROJECT_ROOT, 'test',"test_helper")
+
+
+class CommandExecuterTest < Test::Unit::TestCase
+  context "execute_contract" do
+    should "not execute the contract if dir is nil or empty" do
+      assert_nil CommandExecuter.execute_command(nil,"echo 'Hello'")
+      assert_nil CommandExecuter.execute_command("","echo 'Hello'")
+    end
+
+    should "not execute the contract if command is nil or empty" do
+      assert_nil CommandExecuter.execute_command(Dir.pwd,nil)
+      assert_nil CommandExecuter.execute_command(Dir.pwd,"")
+    end
+
+    should "return the executed command output for valid dir and command" do
+      assert_equal "Hello\n",CommandExecuter.execute_command(Dir.pwd,"echo 'Hello'").unpack("U*").map{|c|c.chr}.join
+    end
+  end
+end

data/test/helper/contract_test.rb

@@ -0,0 +1,60 @@
+require File.join($PROJECT_ROOT, 'lib', 'helper', 'contract')
+require File.join($PROJECT_ROOT, 'test',"test_helper")
+
+class ContractTest < Test::Unit::TestCase
+
+  context "value_of" do
+    should "return the value of the given property of the contract" do
+      key, value = ["command","ls"]
+      params_hash = {key => value, "dir" => "/home"}
+      contract = Contract.new(params_hash)
+      assert_equal  value,contract.value_of(key)
+    end
+
+    should "return nil if the given property is not present in the contract" do
+      contract = Contract.new({})
+      assert_nil contract.value_of("key")
+    end
+  end
+
+  context "has_property?" do
+    should "return true if the property is present in the contract" do
+      key, value = ["command","ls"]
+      params_hash = {key => value}
+      contract = Contract.new(params_hash)
+      assert contract.has_property?(key)
+    end
+    should "return false if the property is not present in the contract" do
+      key, value = ["command","ls"]
+      params_hash = {key => value}
+      contract = Contract.new(params_hash)
+      assert_false contract.has_property?("key")
+    end
+  end
+
+  context "command" do
+    should "return the parameter string replaced in the place of <taas_params> template" do
+      command_template = "play <taas_params> test"
+      parameter_string = "-Dorder_id=1 -Dname=s"
+      contract_hash = {"dir" => "/home", "command" => command_template, "input_param_format" => "-Dkey=value", :input_params =>{:order_id => nil}, :output_params =>{}}
+      parameter = {:order_id => 1, :name => "s"}
+      contract = Contract.new(contract_hash)
+
+      ParameterFactory.stubs(:generate_parameter_string).with("-Dkey=value",parameter).returns(parameter_string)
+
+      assert_equal "play #{parameter_string} test",contract.command(parameter)
+    end
+
+    should "return the parameter string append to command if no <taas_params> template is specified" do
+      command_template = "play test"
+      parameter_string = "order_id=1 name=s"
+      parameter = {:order_id => 1, :name => "s"}
+      contract_hash = {"dir" => "/home", "command" => command_template, "input_param_format" => "key=value", :input_params =>{:order_id => nil}, :output_params =>{}}
+      contract = Contract.new(contract_hash)
+
+      ParameterFactory.stubs(:generate_parameter_string).with("key=value",parameter).returns(parameter_string)
+
+      assert_equal "#{command_template}#{parameter_string}",contract.command(parameter)
+    end
+  end
+end

data/test/helper/contracts_test.rb

@@ -0,0 +1,97 @@
+require File.join($PROJECT_ROOT, 'lib', 'helper', 'contracts')
+require File.join($PROJECT_ROOT, 'test',"test_helper")
+
+
+class ContractsTest < Test::Unit::TestCase
+
+  CONTRACT_HASH = {"contracts"=>{
+      "create_live_sale"=>
+          {"command"=>"bundle exec cucumber",
+           "dir"=>"/home/tworker/work/livesale-automation",
+           "input_params"=>{"name"=>nil, "no_of_listing"=>nil},
+           "timeout_in_seconds"=>100,
+           "output_params"=>{"live_sale_id"=>nil}},
+      "end_live_sale"=>
+          {"command"=>"bundle exec cucumber",
+           "dir"=>"/home/tworker/work/livesale-automation",
+           "input_params"=>{"live_sale_id"=>nil},
+           "timeout_in_seconds"=>100,
+           "output_params"=>{"actual_end_time"=>nil}}}}
+
+  context "load" do
+    should "load the valid contract from contract file" do
+      contract_file_absolute_path = "a1/a5"
+      YAML.stubs(:load_file).with(contract_file_absolute_path).returns(CONTRACT_HASH)
+
+      Contracts.load(contract_file_absolute_path)
+
+      assert_equal false,Contracts.is_empty?
+    end
+
+    should "not load contract if contract file is not present" do
+      contract_file_absolute_path = "a1/a2"
+      YAML.stubs(:load_file).with(contract_file_absolute_path).returns({})
+
+      Contracts.load(contract_file_absolute_path)
+
+      assert_equal true,Contracts.is_empty?
+    end
+
+    should "raise execption if empty or nil contract file is passesd" do
+      assert_raise do
+        Contracts.load(nil)
+      end
+      assert_raise do
+        Contracts.load("")
+      end
+
+    end
+  end
+
+  context "get_contract" do
+    setup {
+      @contract_file_absolute_path = "a1/a2"
+      @contract_name = "create_live_sale"
+    }
+    should "should return the contract object of given contract" do
+      YAML.stubs(:load_file).with(@contract_file_absolute_path).returns(CONTRACT_HASH)
+      Contracts.load(@contract_file_absolute_path)
+
+      assert_equal CONTRACT_HASH["contracts"][@contract_name]["command"],Contracts.get_contract(@contract_name).value_of("command")
+    end
+
+    should "return nil if contract is not present" do
+      YAML.stubs(:load_file).with(@contract_file_absolute_path).returns(CONTRACT_HASH)
+      Contracts.load(@contract_file_absolute_path)
+
+      assert_nil Contracts.get_contract("dummy")
+    end
+  end
+
+  context "is_valid_contract?" do
+    setup {
+      @contract_file_absolute_path = "a1/a2"
+      @contract_name = :create_live_sale
+      YAML.stubs(:load_file).with(@contract_file_absolute_path).returns(CONTRACT_HASH)
+      Contracts.load(@contract_file_absolute_path)
+    }
+    should "return true if requested contract is present" do
+       assert Contracts.contains?("create_live_sale")
+    end
+    should "return false if requested contract is not present" do
+      assert_false Contracts.contains?("dummy_contract")
+    end
+  end
+
+  context "get_all_contracts" do
+    setup {
+      @contract_file_absolute_path = "a1/a2"
+      @contract_name = :create_live_sale
+      YAML.stubs(:load_file).with(@contract_file_absolute_path).returns(CONTRACT_HASH)
+      Contracts.load(@contract_file_absolute_path)
+    }
+    should "return all the contracts" do
+      assert_equal CONTRACT_HASH["contracts"],Contracts.get_all_contracts
+    end
+  end
+end

data/test/helper/output_parser_test.rb

@@ -0,0 +1,75 @@
+require File.join($PROJECT_ROOT,'lib', 'helper', 'output_parser')
+require File.join($PROJECT_ROOT, 'test',"test_helper")
+
+
+class OutputParserTest < Test::Unit::TestCase
+  context "parse_taas_output" do
+    should "return TaaS specific parsed json TaaS from the output" do
+      response_json = '"paas":"true","data":{}'
+      output = "this is core output.<TaaS Response Start>#{response_json}<TaaS Response Complete>"
+
+      assert_equal OutputParser.parse_taas_output(output),response_json
+    end
+
+    should "return nil if the output format is not correct" do
+      response_json = '"paas":"true","data":{}'
+      output = "this is core output.#{response_json}<TaaS Response Complete>"
+
+      assert_nil OutputParser.parse_taas_output(output)
+    end
+  end
+
+  context "parse server output" do
+    should "return the parameter hash and command output from server dump" do
+      output="this is dummy output"
+      response_json = '{"paas":"true","data":{}}'
+      server_response="<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output><TaaS-Json>#{response_json}</TaaS-Json></TaaS-Server-Response>"
+      response_hash = JSON.parse(response_json)
+
+      assert_equal [response_hash, output],OutputParser.parse_server_output(server_response)
+
+    end
+
+    should "return nil if server dump is not of taas output standard" do
+      output="this is dummy output"
+      response_json = '{"paas":"true","data":{}}'
+      server_response_1="<TaaS-Server-Response>#{output}</TaaS-Output><TaaS-Json>#{response_json}</TaaS-Json></TaaS-Server-Response>"
+      server_response_2="<TaaS-Server-Response><Taas-Output>#{output}<TaaS-Json>#{response_json}</TaaS-Json></TaaS-Server-Response>"
+      server_response_3="<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output>#{response_json}</TaaS-Json></TaaS-Server-Response>"
+      server_response_4="<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output><TaaS-Json>#{response_json}</TaaS-Server-Response>"
+      server_response_5="<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output><TaaS-Json>yello</TaaS-Json></TaaS-Server-Response>"
+
+      assert_nil OutputParser.parse_server_output(server_response_1)
+      assert_nil OutputParser.parse_server_output(server_response_2)
+      assert_nil OutputParser.parse_server_output(server_response_3)
+      assert_nil OutputParser.parse_server_output(server_response_4)
+      assert_nil OutputParser.parse_server_output(server_response_5)
+    end
+  end
+
+  context "valid_server_response?" do
+
+    should "return false if the response is not same as TaaS server template" do
+      server_output = "<TaaS-Server-Response>Dummy output</TaaS-Output><TaaS-Json>dummy json</TaaS-Json></TaaS-Server-Response>"
+      assert_false OutputParser.valid_server_response?(server_output)
+
+      server_output = "<TaaS-Server-Response><Taas-Output>Dummy output<TaaS-Json>dummy json</TaaS-Json></TaaS-Server-Response>"
+      assert_false OutputParser.valid_server_response?(server_output)
+
+      server_output = "<TaaS-Server-Response><Taas-Output>Dummy output</TaaS-Output>dummy json</TaaS-Json></TaaS-Server-Response>"
+      assert_false OutputParser.valid_server_response?(server_output)
+
+      server_output = "<TaaS-Server-Response><Taas-Output>Dummy output</TaaS-Output><TaaS-Json>dummy json</TaaS-Server-Response>"
+      assert_false OutputParser.valid_server_response?(server_output)
+
+    end
+
+    should "return true if the response is not same as TaaS server template" do
+      server_output =  "<TaaS-Server-Response><Taas-Output>Dummy output</TaaS-Output><TaaS-Json>dummy json</TaaS-Json></TaaS-Server-Response>"
+      assert OutputParser.valid_server_response?(server_output)
+    end
+
+  end
+end
+
+

data/test/helper/parameter_factory_test.rb

@@ -0,0 +1,31 @@
+require File.join($PROJECT_ROOT,'lib', 'helper', 'parameter_factory')
+require File.join($PROJECT_ROOT, 'test',"test_helper")
+
+class ParameterFactoryTest < Test::Unit::TestCase
+
+  context "generate_parameter_string" do
+    should "create command line params string in given template" do
+      template ="-Dkey=value"
+      params_hash = {:order_id => 1, :name => "s"}
+      expected_string = " -Dorder_id=1 -Dname=s"
+
+      generated_string = ParameterFactory.generate_parameter_string(template,params_hash)
+
+      assert_true generated_string.include?("-Dorder_id=1")
+      assert_true generated_string.include?("-Dname=s")
+      puts generated_string.gsub("-Dname=s","").gsub("-Dorder_id=1","")
+
+    end
+
+    should "create command line in params in key=value template if no template is specified" do
+      params_hash = {:order_id => 1, :name => "s"}
+      expected_string = " order_id=1 name=s"
+
+      generated_string = ParameterFactory.generate_parameter_string(nil,params_hash)
+
+      assert_true generated_string.include?("order_id=1")
+      assert_true generated_string.include?("name=s")
+
+    end
+  end
+end

data/test/server_test.rb

@@ -0,0 +1,109 @@
+require File.join($PROJECT_ROOT, 'lib', 'server')
+require File.join($PROJECT_ROOT, 'test',"test_helper")
+
+ENV['RACK_ENV']='test'
+
+class ServerTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Sinatra::Application
+  end
+
+  context "post /contract" do
+    should "return the pass attribute as false if the contract is not loaded" do
+      contract_name = "Do Not Exists"
+      file_name = "file_name"
+      Contracts.stubs(:load).with(ARGV[0]).returns(file_name)
+      Contracts.stubs(:is_empty?).returns(true)
+      output = "Contract Name is either nil or not valid."
+      response_json = '{"pass":"false","data":{}}'
+
+      post "/contract", params = {:contract_name => "Do Not Exists"}
+
+      assert last_response.ok?
+      assert_true last_response.body.include?("<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output><TaaS-Json>#{response_json}</TaaS-Json></TaaS-Server-Response>")
+
+    end
+    should "return the pass attribute as false if the contract is loaded but requested contract is not valid" do
+      contract_name = "Do Not Exists"
+      file_name = "file_name"
+      Contracts.stubs(:load).with(ARGV[0]).returns(file_name)
+      Contracts.stubs(:is_empty?).returns(false)
+      Contracts.stubs(:contains?).with(contract_name).returns(false)
+      output = "Contract Name is either nil or not valid."
+      response_json = '{"pass":"false","data":{}}'
+
+      post "/contract", params = {:contract_name => "Do Not Exists"}
+
+      assert last_response.ok?
+      assert last_response.body.include?("<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output><TaaS-Json>#{response_json}</TaaS-Json></TaaS-Server-Response>")
+
+    end
+
+    should "not return pass attribute as false if the specificed contract do not exist but CONTACT_MANGER is initialized" do
+      contract_name = "Do Not Exists"
+      file_name = "file_name"
+      Contracts.stubs(:load).with(ARGV[0]).returns(file_name)
+      Contracts.stubs(:contains?).with(contract_name).returns(false)
+      output = "Contract Name is either nil or not valid."
+      response_json = '{"pass":"false","data":{}}'
+
+      post "/contract", params = {:contract_name => "Do Not Exists"}
+
+      assert last_response.ok?
+      assert last_response.body.include?("<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output><TaaS-Json>#{response_json}</TaaS-Json></TaaS-Server-Response>")
+    end
+
+
+
+    should "return the raw output from the executed contract" do
+      command = "a"
+      dir = "/taas/executiondir"
+      response_json = '{"pass":"true","data":{"params1":"value1","params2":"value2"}'
+      output = "All files and dir<TaaS Response Start>#{response_json}<TaaS Response Complete>"
+      contract_name = "Contract Exists"
+      params = {"contract_name" => contract_name}
+      contract = Contract.new({})
+      file_name = "file_name"
+      Contracts.stubs(:load).with(ARGV[0]).returns(file_name)
+      Contracts.stubs(:is_empty?).returns(false)
+      Contracts.stubs(:contains?).with(contract_name).returns(true)
+      Contracts.stubs(:get_contract).with(contract_name).returns(contract)
+      Contract.any_instance.stubs(:command).with(params).returns(command)
+      Contract.any_instance.stubs(:value_of).with("dir").returns(dir)
+      CommandExecuter.stubs(:execute_command).with(dir,command).returns(output)
+      OutputParser.stubs(:parse_taas_output).with(output).returns(response_json)
+
+      post "/contract", params
+
+      assert last_response.ok?
+      assert last_response.body.include?("<TaaS-Server-Response><Taas-Output>#{output}</TaaS-Output><TaaS-Json>#{response_json}</TaaS-Json></TaaS-Server-Response>")
+    end
+  end
+
+
+  context "get /" do
+
+    should "display the table version of the loaded Contracts" do
+      contract_name = "Do Not Exists"
+      file_name = "file_name_get"
+      Contracts.stubs(:load).with(ARGV[0]).returns(file_name)
+      Contracts.stubs(:get_all_contracts).returns({"c1" => {"command" => "one","dir"=>"pwd"},"c2" => {"command" => "two","dir"=>"pwd1"} })
+
+      get "/"
+
+      assert last_response.ok?
+      assert_true last_response.body.include?("command")
+      assert_true last_response.body.include?("c1")
+      assert_true last_response.body.include?("one")
+      assert_true last_response.body.include?("pwd")
+      assert_true last_response.body.include?("pwd")
+      assert_true last_response.body.include?("c2")
+      assert_true last_response.body.include?("two")
+      assert_true last_response.body.include?("pwd1")
+
+    end
+  end
+
+    end

data/test/taas_client_test.rb

@@ -0,0 +1,64 @@
+require File.join($PROJECT_ROOT, 'lib', 'taas_client')
+require File.join($PROJECT_ROOT, 'test',"test_helper")
+
+
+class TaaSClientTest < Test::Unit::TestCase
+
+  context "execute_contract" do
+    setup do
+      @taas_client = TaaSClient.new("http://taas-url.com/")
+      @params = {:contract_name => "create_xyz", :params  => {:params_one => "one", :params_n => "params n"}}
+      @response_json = '"pass":"true","data":{}'
+      @hash = {:pass => true, :data => {}}
+      @output="This is a Dummy Output"
+      @server_output = "<TaaS-Server-Response><Taas-Output>#{@output}</TaaS-Output><TaaS-Json>#{@response_json}</TaaS-Json></TaaS-Server-Response>"
+    end
+    should "return hash and command output of server if failed is false" do
+      @taas_client.stubs(:request_taas_server).with(@params).returns(@server_output)
+      OutputParser.stubs(:valid_server_response?).with(@server_output).returns(true)
+      values = lambda {return @output,@hash}
+      OutputParser.stubs(:parse_server_output).with(@server_output).returns(values.call)
+
+      command_output, response_hash = @taas_client.execute_contract(@params)
+
+      assert_equal command_output,@output
+      assert_equal response_hash, @hash
+    end
+
+
+    should "raise an error if validate_server returns false" do
+      @taas_client.stubs(:request_taas_server).with(@params).returns(@server_output)
+      OutputParser.stubs(:valid_server_response?).with(@server_output).returns(false)
+
+      assert_raise do
+        @taas_client.execute_contract(@params)
+      end
+    end
+  end
+
+
+
+  context "request_taas_server" do
+    should "return the body of the taas server response" do
+        input_params = {:name => "taas"}
+        output_params = {"id"=>1, "json_response"=>{}}
+        taas_client = TaaSClient.new("http://localhost:4567/")
+
+        uri = URI.parse("http://localhost:4567/")
+        URI.stubs(:parse).with("http://localhost:4567/").returns(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        Net::HTTP.stubs(:new).with(uri.host,uri.port).returns(http)
+        stub_request = Net::HTTP::Post.new(uri.request_uri)
+        Net::HTTP::Post.stubs(:new).with(uri.request_uri).returns(stub_request)
+        stub_request.stubs(:set_form_data).with(input_params).returns(true)
+        stub_request.stubs(:read_timeout=).with(1000*10000).returns(true)
+
+        command_output = "This is command output"
+        response = "<Taas command output start>#{command_output}<Taas command output ends>{\"id\":1,\"json_response\":{}}"
+        http.stubs(:request).with(stub_request).returns(response)
+        response.stubs(:body).returns(response)
+
+        assert response,taas_client.request_taas_server(input_params)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require "rubygems"
+require "test/unit"
+require "yaml"
+require "mocha"
+require "json"
+require "rack/test"
+require "shoulda"
+
+include TaaS
+
+

metadata

@@ -0,0 +1,229 @@
+--- !ruby/object:Gem::Specification 
+name: taas
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Anand Bagmar, Akash Mishra
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-04-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  prerelease: false
+  name: rake
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id002
+  prerelease: false
+  name: sinatra
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
+  prerelease: false
+  name: json
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  prerelease: false
+  name: test-unit
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+  prerelease: false
+  name: mocha
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id006
+  prerelease: false
+  name: shoulda
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id007
+  prerelease: false
+  name: rack-test
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id008
+  prerelease: false
+  name: jeweler
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id009
+  prerelease: false
+  name: pry
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id010
+  prerelease: false
+  name: pry-nav
+  type: :development
+description: "\"TaaS\" allows you to validate the integration across a variety of products via Test Automation - the \"correct\" way. TaaS uses a web service interface to run your end-2-end integration tests between two independent but related system. See the blog for more details: http://goo.gl/nVShb"
+email: 
+- abagmar@gmail.com, akash.mishra20@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/helper/command_executer.rb
+- lib/helper/contract.rb
+- lib/helper/contracts.rb
+- lib/helper/output_parser.rb
+- lib/helper/parameter_factory.rb
+- lib/server.rb
+- lib/taas.rb
+- lib/taas/version.rb
+- lib/taas_client.rb
+- taas.gemspec
+- test/helper/command_executer_test.rb
+- test/helper/contract_test.rb
+- test/helper/contracts_test.rb
+- test/helper/output_parser_test.rb
+- test/helper/parameter_factory_test.rb
+- test/server_test.rb
+- test/taas_client_test.rb
+- test/test_helper.rb
+homepage: http://github.com/anandbagmar/taas
+licenses: 
+- Apache 2.0
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: taas
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: TaaS
+test_files: []
+