opensrs 0.3.4 → 0.4.0

data/README.rdoc

@@ -1,105 +0,0 @@
-= OpenSRS
-
-{<img src="https://travis-ci.org/voxxit/opensrs.png" />}[https://travis-ci.org/voxxit/opensrs]
-{<img src="https://codeclimate.com/github/voxxit/opensrs.png" />}[https://codeclimate.com/github/voxxit/opensrs]
-
-This (unofficial) OpenSRS gem provides basic support to connect to, and utilize the OpenSRS API. This library has been well-tested in high-performance production
-environments. More information on the API can be located here:
-
-http://www.opensrs.com/site/resources/documentation/api
-
-== Installation
-
-You can install this gem by doing the following:
-
-  $ gem install opensrs
-
-You can then include it in a Ruby project, like so:
-
-  require 'opensrs'
-
-Alternatively, you can include it in a Rails 2.x project in the <tt>environment.rb</tt> file, like so:
-
-  config.gem "opensrs"
-
-For Rails 3.x, use the <tt>Gemfile</tt>:
-
-  gem "opensrs"
-
-== Usage
-
-This library provides basic functionality for interacting with the OpenSRS XML API.
-
-* Connection handling
-* Error reporting
-* XML encoding
-* XML decoding
-
-Currently, the library supports LibXML and Nokogiri as XML parsers. By default, it uses LibXML to parse and generate XML. If you'd like to use Nokogiri (1.4.7 and below) for parsing XML, then in one of your app initializers add the following line:
-
-  OpenSRS::Server.xml_processor = :nokogiri
-
-To connect, instantiate a new <tt>OpenSRS::Server</tt> object:
-
-  server = OpenSRS::Server.new(
-    :server   => "https://rr-n1-tor.opensrs.net:55443/",
-    :username => "testing",
-    :password => "53cr3t",
-    :key      => "c633be3170c7fb3fb29e2f99b84be2410..."
-  )
-
-NOTE: Connecting to OpenSRS requires that you add the IP(s) you're connecting from to their whitelist. Login to the testing or production servers, and add your IP(s) under Profile Management > Add IPs for Script/API Access. IP changes take about one hour to take effect.
-
-Once you have a server connection class, you can build from this to create the methods that you need. For instance, let's say we want to grab our account balance. The OpenSRS XML API takes a couple of attributes for all commands. You can include those here:
-
-  def get_balance
-    server.call(
-      :action => "GET_BALANCE",
-      :object => "BALANCE"
-    )
-  end
-
-Sometimes you might need to include attributes for the command, such as a cookie, or the data attributes themselves. You can do this, too:
-
-  def create_nameserver(nameserver)
-    server.call(
-      :action => "CREATE",
-      :object => "NAMESERVER",
-      :cookie => "366828736:3210384",
-      :attributes => {
-        :name => nameserver.hostname,
-        :ipaddress => "212.112.123.11"
-      }
-    )
-  end
-
-Responses from OpenSRS are returned in an OpenSRS::Response object, which gives you access to a multitude of things.
-
-* <tt>response.response</tt> - This gives you the response in a Hash form, which is highly accessible to most other actions in your application.
-* <tt>response.errors</tt> - If there are errors which come back from OpenSRS, they are returned here. If not, it returns nil.
-* <tt>response.success?</tt> - Returns true if the response was labeled as successful. If not, it returns false.
-* <tt>response.request_xml</tt> - Returns raw request XML.
-* <tt>response.response_xml</tt> - Returns raw response XML.
-
-== Bugs/Feature Requests
-
-If you have any bugs or feature requests for this gem, feel free to add them in the Issues portion of the GitHub repository here:
-
-http://github.com/voxxit/opensrs/issues
-
-== Note on Patches/Pull Requests
-
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a future version unintentionally.
-* Commit, do not mess with rakefile, version, or history. If you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull.
-* Send me a pull request. Bonus points for topic branches.
-
-== Contributors (in order of appearance)
-
-* Josh Delsman
-* Glenn Roberts
-
-== Copyright
-
-Copyright (c) 2010-2013 Josh Delsman. Distributed under the MIT license. See LICENSE for details.

data/spec/opensrs/server_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-describe OpenSRS::Server do
-  let(:server) { OpenSRS::Server.new }
-
-  describe '#new' do
-    it 'allows timeouts to be set' do
-      server = OpenSRS::Server.new({ :timeout => 90 })
-      server.timeout.should == 90
-      server.open_timeout.should be_nil
-    end
-
-    it 'allows open timeouts to be set' do
-      server = OpenSRS::Server.new({ :timeout => 90, :open_timeout => 10 })
-      server.timeout.should eq(90)
-      server.open_timeout.should eq(10)
-    end
-
-    it 'leaves it up to Net::HTTP if no timeouts given' do
-      server.timeout.should be_nil
-      server.open_timeout.should be_nil
-    end
-  end
-
-  describe ".call" do
-    let(:response) { double(:body => 'some response') }
-    let(:header) { {"some" => "header" } }
-    let(:xml) { '<some xml></some xml>' }
-    let(:response_xml) { xml }
-    let(:xml_processor) { double OpenSRS::XmlProcessor }
-    let(:http) { double(Net::HTTP, :use_ssl= => true, :verify_mode= => true)  }
-
-    before :each do
-      server.stub(:headers).and_return header
-      xml_processor.stub(:build).and_return xml
-      xml_processor.stub(:parse).and_return response_xml
-      server.stub(:xml_processor).and_return xml_processor
-      http.stub(:post).and_return response
-      Net::HTTP.stub(:new).and_return http
-    end
-
-    it "builds XML request" do
-      xml_processor.should_receive(:build).with(:protocol => "XCP", :some => 'option')
-      server.call(:some => 'option')
-    end
-
-    it "posts to given path" do
-      server.server = URI.parse 'http://with-path.com/endpoint'
-      http.should_receive(:post).with('/endpoint', xml, header).and_return double.as_null_object
-      server.call
-    end
-
-    it "parses the response" do
-      xml_processor.should_receive(:parse).with(response.body)
-      server.call(:some => 'option')
-    end
-
-    it "posts to root path" do
-      server.server = URI.parse 'http://root-path.com/'
-      http.should_receive(:post).with('/', xml, header).and_return double.as_null_object
-      server.call
-    end
-
-    it "defaults path to '/'" do
-      server.server = URI.parse 'http://no-path.com'
-      http.should_receive(:post).with('/', xml, header).and_return double.as_null_object
-      server.call
-    end
-
-    it 'allows overriding of default (Net:HTTP) timeouts' do
-      server.timeout = 90
-
-      http.should_receive(:open_timeout=).with(90)
-      http.should_receive(:read_timeout=).with(90)
-
-      server.call( { :some => 'data' } )
-    end
-
-    it 'allows overriding of default (Net:HTTP) timeouts' do
-      server.timeout = 180
-      server.open_timeout = 30
-
-      http.should_receive(:read_timeout=).with(180)
-      http.should_receive(:open_timeout=).with(180)
-      http.should_receive(:open_timeout=).with(30)
-
-      server.call( { :some => 'data' } )
-    end
-
-    it 're-raises Net:HTTP timeouts' do
-      http.should_receive(:post).and_raise err = Timeout::Error.new('test')
-      expect { server.call }.to raise_exception OpenSRS::TimeoutError
-    end
-  end
-
-  describe "#test xml processor" do
-    context "on class initialization" do
-      it { server.xml_processor.should eql(OpenSRS::XmlProcessor::Libxml) }
-    end
-
-    context "on changing xml processor" do
-      before(:each) do
-        OpenSRS::Server.xml_processor = :nokogiri
-      end
-
-      it { server.xml_processor.should eql(OpenSRS::XmlProcessor::Nokogiri) }
-    end
-  end
-end

data/spec/opensrs/version_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe OpenSRS::Version do
-  describe "VERSION" do
-    it "should return version string" do
-      OpenSRS::Version::VERSION.should eql("0.3.3")
-    end
-  end
-end

data/spec/opensrs/xml_processor/libxml_spec.rb

@@ -1,254 +0,0 @@
-require 'spec_helper'
-require 'date'
-
-describe OpenSRS::XmlProcessor::Libxml do
-  describe ".build" do    
-    it "should create XML for a nested hash" do
-      attributes = {:foo => {:bar => 'baz'}}
-      xml = OpenSRS::XmlProcessor::Libxml.build(attributes)
-      xml.should eq %{<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<OPS_envelope>\n  <header>\n    <version>0.9</version>\n  </header>\n  <body>\n    <data_block>\n      <dt_assoc>\n        <item key=\"foo\">\n          <dt_assoc>\n            <item key=\"bar\">baz</item>\n          </dt_assoc>\n        </item>\n      </dt_assoc>\n    </data_block>\n  </body>\n</OPS_envelope>\n}
-    end
-  end
-  
-  describe '.encode_data' do
-    context "on a 3 element array" do
-      before(:each) do
-        @e = OpenSRS::XmlProcessor::Libxml.encode_data([1,2,3])
-      end
-      
-      it "is a REXML::Element" do
-        @e.should be_an_instance_of(LibXML::XML::Node)
-      end
-
-      it "is a dt_array" do
-        @e.name.should == 'dt_array'
-      end
-
-      it "has 3 children all called <item>" do
-        @e.should have(3).children
-        @e.children[0].name.should == "item"
-        @e.children[1].name.should == "item"
-        @e.children[2].name.should == "item"
-      end
-
-      it "has children with keys 0, 1 and 2" do
-        @e.children[0].attributes["key"].should == "0"
-        @e.children[1].attributes["key"].should == "1"
-        @e.children[2].attributes["key"].should == "2"
-      end
-    end
-
-    context "on a hash" do
-      before(:each) do
-        @e = OpenSRS::XmlProcessor::Libxml.encode_data({:name => "kitteh"})
-      end
-
-      it "is a REXML::Element" do
-        @e.should be_an_instance_of(LibXML::XML::Node)
-      end
-
-      it "is a dt_assoc" do
-        @e.name.should == 'dt_assoc'
-      end
-
-      it "has an <item> child with the right key" do
-        @e.should have(1).children
-        @e.children[0].name.should == 'item'
-        @e.children[0].attributes["key"].should == 'name'
-      end
-    end
-    
-    context "on a nested hash" do
-      before(:each) do
-        @e = OpenSRS::XmlProcessor::Libxml.encode_data({:suggestion => {:maximum => "10"}})
-      end
-      
-      it "is a REXML::Element" do
-        @e.should be_an_instance_of(LibXML::XML::Node)
-      end
-
-      it "is a dt_assoc" do
-        @e.name.should == 'dt_assoc'
-      end
-      
-      it "has an <item> child with the correct children" do
-        @e.should have(1).children
-        suggestion = @e.children[0]
-        suggestion.name.should == 'item'
-        suggestion.attributes["key"].should == 'suggestion'
-        
-        suggestion.should have(1).children
-        dt_assoc = suggestion.children[0]
-        dt_assoc.name.should == 'dt_assoc'
-        
-        dt_assoc.should have(1).children
-        maximum = dt_assoc.children[0]
-        maximum.name.should == 'item'
-        maximum.attributes["key"].should == 'maximum'
-      end
-    end
-
-    context "produces a scalar" do
-      it "from a string" do
-        OpenSRS::XmlProcessor::Libxml.encode_data("cheezburger").to_s.should == "cheezburger"
-      end
-
-      it "from a string with XML characters" do
-        OpenSRS::XmlProcessor::Libxml.encode_data("<smile>").to_s.should == "<smile>"
-      end
-
-      it "from an integer" do
-        OpenSRS::XmlProcessor::Libxml.encode_data(12345).to_s.should == "12345"
-      end
-
-      it "from a date" do
-        date = Date.parse("2010/02/12")
-        OpenSRS::XmlProcessor::Libxml.encode_data(date).to_s.should == "2010-02-12"
-      end
-
-      it "from a symbol" do
-        OpenSRS::XmlProcessor::Libxml.encode_data(:name).to_s.should == "name"
-      end
-
-      it "from true or false" do
-        OpenSRS::XmlProcessor::Libxml.encode_data(true).to_s.should == "true"
-        OpenSRS::XmlProcessor::Libxml.encode_data(false).to_s.should == "false"
-      end
-    end
-  end
-
-  describe '.parse' do
-    it "should handle scalar values" do
-      xml = %{<?xml version='1.0' encoding='UTF-8' standalone='no' ?>
-        <!DOCTYPE OPS_envelope SYSTEM 'ops.dtd'>
-        <OPS_envelope>
-          <header>
-            <version>1.0</version>
-          </header>
-          <body>
-            <data_block>
-              <dt_scalar>Tom Jones</dt_scalar>
-            </data_block>
-          </body>
-        </OPS_envelope>}
-        
-      resp = OpenSRS::XmlProcessor::Libxml.parse(xml)
-      resp.should == "Tom Jones"
-    end
-    
-    it "should handle associate arrays with arrays of values" do
-      xml = %{<?xml version='1.0' encoding='UTF-8' standalone='no' ?>
-      <!DOCTYPE OPS_envelope SYSTEM 'ops.dtd'>
-      <OPS_envelope>
-        <header>
-          <version>1.0</version>
-        </header>
-        <body>
-          <data_block>
-            <dt_assoc>
-              <item key='domain_list'>
-                <dt_array>
-                  <item key='0'>ns1.example.com</item>
-                  <item key='1'>ns2.example.com</item>
-                  <item key='2'>ns3.example.com</item>
-                </dt_array>
-              </item>
-            </dt_assoc>    
-          </data_block>
-        </body>
-      </OPS_envelope>}
-        
-      resp = OpenSRS::XmlProcessor::Libxml.parse(xml)
-      resp["domain_list"].class.should == Array
-      resp["domain_list"][0].should == "ns1.example.com"
-      resp["domain_list"][1].should == "ns2.example.com"
-      resp["domain_list"][2].should == "ns3.example.com"
-    end
-    
-    it "should handle associative arrays containing other associative arrays" do
-      xml = %{<?xml version='1.0' encoding='UTF-8' standalone='no' ?>
-      <!DOCTYPE OPS_envelope SYSTEM 'ops.dtd'>
-      <OPS_envelope>
-        <header>
-          <version>1.0</version>
-        </header>
-        <body>
-          <data_block>
-            <dt_assoc>
-              <item key="contact_set">
-                <dt_assoc>
-                  <item key='owner'>
-                    <dt_assoc>
-                      <item key='first_name'>Tom</item>
-                      <item key='last_name'>Jones</item>
-                    </dt_assoc> 
-                  </item>
-                  <item key='tech'>
-                    <dt_assoc>
-                      <item key='first_name'>Anne</item>
-                      <item key='last_name'>Smith</item>
-                    </dt_assoc>
-                  </item>
-                </dt_assoc>
-              </item>
-            </dt_assoc>
-          </data_block>
-        </body> 
-      </OPS_envelope>}
-      
-      resp = OpenSRS::XmlProcessor::Libxml.parse(xml)
-      
-      resp["contact_set"]["owner"]["first_name"].should == "Tom"
-      resp["contact_set"]["owner"]["last_name"].should == "Jones"
-      resp["contact_set"]["tech"]["first_name"].should == "Anne"
-      resp["contact_set"]["tech"]["last_name"].should == "Smith"
-    end
-    
-    context "with a balance enquiry example response" do
-      before(:each) do
-        xml = %{<?xml version='1.0' encoding='UTF-8' standalone='no' ?>
-          <!DOCTYPE OPS_envelope SYSTEM 'ops.dtd'>
-          <OPS_envelope>
-            <header>
-              <version>0.9</version>
-            </header>
-            <body>
-              <data_block>
-                <dt_assoc>
-                  <item key="protocol">XCP</item>
-                  <item key="action">REPLY</item>
-                  <item key="object">BALANCE</item>
-                  <item key="is_success">1</item>
-                  <item key="response_code">200</item>
-                  <item key="response_text">Command successful</item>
-                  <item key="attributes">
-                    <dt_assoc>
-                      <item key="balance">8549.18</item>
-                      <item key="hold_balance">1676.05</item>
-                    </dt_assoc>
-                  </item>
-                </dt_assoc>
-              </data_block>
-            </body>
-          </OPS_envelope>}
-        
-        @resp = OpenSRS::XmlProcessor::Libxml.parse(xml)
-      end
-
-      it "produces a hash" do
-        @resp.should be_an_instance_of(Hash)
-      end
-
-      it "has top level keys" do
-        @resp["protocol"].should == "XCP"
-        @resp["action"].should == "REPLY"
-        @resp["object"].should == "BALANCE"
-      end
-
-      it "has second level keys" do
-        @resp["attributes"]["balance"].should == "8549.18"
-        @resp["attributes"]["hold_balance"].should == "1676.05"
-      end
-    end
-  end
-end