haproxy-tools 0.5.0 → 0.6.0

data/lib/haproxy/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HAProxy
-  VERSION = "0.5.0"
+  VERSION = "0.6.0".freeze
 end

data/lib/haproxy_tools.rb

@@ -1,5 +1,7 @@
-require 'treetop'
-require 'haproxy/treetop/config'
-require 'haproxy/config'
-require 'haproxy/renderer'
-require 'haproxy/parser'
+# frozen_string_literal: true
+
+require "treetop"
+require "haproxy/treetop/config"
+require "haproxy/config"
+require "haproxy/renderer"
+require "haproxy/parser"

data/spec/haproxy/config_spec.rb

@@ -1,142 +1,153 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe "HAProxy::Config" do
-  describe 'render multi-backend config' do
+  describe "render multi-backend config" do
     before(:each) do
-      @config = HAProxy::Config.parse_file('spec/fixtures/multi-pool.haproxy.cfg')
+      @config = HAProxy::Config.parse_file("spec/fixtures/multi-pool.haproxy.cfg")
     end
 
-    it 'can re-render a config file with a server removed' do
-      l = @config.backend('www_main')
-      l.servers.delete('prd_www_1')
+    it "can re-render a config file with a server removed" do
+      l = @config.backend("www_main")
+      l.servers.delete("prd_www_1")
 
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      new_config.backend('www_main').servers['prd_www_1'].should be_nil
+      expect(new_config.backend("www_main").servers["prd_www_1"]).to be_nil
     end
 
-    it 'can re-render a config file with a server attribute added' do
-      b = @config.backend('www_main')
-      b.servers['prd_www_1'].attributes['disabled'] = true
+    it "can re-render a config file with a server attribute added" do
+      b = @config.backend("www_main")
+      b.servers["prd_www_1"].attributes["disabled"] = true
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      s = new_config.backend('www_main').servers['prd_www_1']
-      s.should_not be_nil
-      s.attributes['disabled'].should be_truthy
+      s = new_config.backend("www_main").servers["prd_www_1"]
+      expect(s).not_to be_nil
+      expect(s.attributes["disabled"]).to be_truthy
     end
 
-    it 'can re-render a config file with a server added' do
-      b = @config.backend('www_main')
-      b.add_server('prd_www_4', '99.99.99.99', :port => '8000', attributes: { :weight => 128 })
+    it "can re-render a config file with a server added" do
+      b = @config.backend("www_main")
+      b.add_server("prd_www_4", "99.99.99.99", port: "8000", attributes: {weight: 128})
 
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      s = new_config.backend('www_main').servers['prd_www_4']
-      s.should_not be_nil
-      s.name.should == 'prd_www_4'
-      s.host.should == '99.99.99.99'
-      s.port.should == '8000'
-      s.attributes.to_a.should == [['weight', '128']]
+      s = new_config.backend("www_main").servers["prd_www_4"]
+      expect(s).not_to be_nil
+      expect(s.name).to eq("prd_www_4")
+      expect(s.host).to eq("99.99.99.99")
+      expect(s.port).to eq("8000")
+      expect(s.attributes.to_a).to eq([["weight", "128"]])
     end
 
-    it 'can re-render a config file with a server added based on template' do
-      b = @config.backend('www_main')
-      b.add_server('prd_www_4', '99.99.99.99', :template => b.servers['prd_www_1'])
+    it "can re-render a config file with a server added based on template" do
+      b = @config.backend("www_main")
+      b.add_server("prd_www_4", "99.99.99.99", template: b.servers["prd_www_1"])
 
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      s = new_config.backend('www_main').servers['prd_www_4']
-      s.should_not be_nil
-      s.name.should == 'prd_www_4'
-      s.host.should == '99.99.99.99'
-      s.port.should == '8000'
-      s.attributes.to_a.should == [
-        ['cookie','i-prd_www_1'],
-        ['check',true],
-        ['inter','3000'],
-        ['rise','2'],
-        ['fall','3'],
-        ['maxconn','1000']
-      ]
+      s = new_config.backend("www_main").servers["prd_www_4"]
+      expect(s).not_to be_nil
+      expect(s.name).to eq("prd_www_4")
+      expect(s.host).to eq("99.99.99.99")
+      expect(s.port).to eq("8000")
+      expect(s.attributes.to_a).to eq([
+        ["cookie", "i-prd_www_1"],
+        ["check", true],
+        ["inter", "3000"],
+        ["rise", "2"],
+        ["fall", "3"],
+        ["maxconn", "1000"],
+      ])
+    end
+  end
+
+  describe "re-render multi-pool config" do
+    before(:each) do
+      @config = HAProxy::Config.parse_file("spec/fixtures/multi-pool.haproxy.cfg")
+    end
+
+    it "can re-render the config file" do
+      original_text = File.read("spec/fixtures/multi-pool.haproxy.cfg")
+      new_text = @config.render
+      expect(new_text.squeeze(" ")).to eq(original_text.squeeze(" "))
     end
   end
 
-  describe 'render simple 1.5 config' do
+  describe "render simple 1.5 config" do
     before(:each) do
-      @config = HAProxy::Config.parse_file('spec/fixtures/simple.haproxy15.cfg')
+      @config = HAProxy::Config.parse_file("spec/fixtures/simple.haproxy15.cfg")
     end
 
-    it 'cen re-render a config file with an error page removed' do
-      @config.default.config.should have_key('errorfile 400')
-      @config.default.config.delete('errorfile 400')
+    it "can re-render a config file with an error page removed" do
+      expect(@config.default.config).to have_key("errorfile 400")
+      @config.default.config.delete("errorfile 400")
 
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      new_config.default.config.should_not have_key('errorfile 400')
+      expect(new_config.default.config).not_to have_key("errorfile 400")
     end
 
-    it 'can re-render a config file with an error page added' do
-      @config.default.config.should_not have_key('errorfile 401')
-      @config.default.config['errorfile 401'] = '/etc/haproxy/errors/401.http'
+    it "can re-render a config file with an error page added" do
+      expect(@config.default.config).not_to have_key("errorfile 401")
+      @config.default.config["errorfile 401"] = "/etc/haproxy/errors/401.http"
 
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      new_config.default.config.should have_key('errorfile 401')
-      new_config.default.config['errorfile 401'].should == '/etc/haproxy/errors/401.http'
+      expect(new_config.default.config).to have_key("errorfile 401")
+      expect(new_config.default.config["errorfile 401"]).to eq("/etc/haproxy/errors/401.http")
     end
-
   end
 
-  describe 'render simple config' do
+  describe "render simple config" do
     before(:each) do
-      @config = HAProxy::Config.parse_file('spec/fixtures/simple.haproxy.cfg')
+      @config = HAProxy::Config.parse_file("spec/fixtures/simple.haproxy.cfg")
     end
 
-    it 'can re-render a config file with a config removed' do
-      @config.default.config.should have_key('clitimeout')
-      @config.default.config.delete('clitimeout')
+    it "can re-render a config file with a config removed" do
+      expect(@config.default.config).to have_key("clitimeout")
+      @config.default.config.delete("clitimeout")
 
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      new_config.default.config.should_not have_key('clitimeout')
-
+      expect(new_config.default.config).not_to have_key("clitimeout")
     end
 
-    it 'can re-render a config file with a server removed' do
-      l = @config.listener('http_proxy')
-      l.servers.delete('web1')
+    it "can re-render a config file with a server removed" do
+      l = @config.listener("http_proxy")
+      l.servers.delete("web1")
 
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      new_config.listener('http_proxy').servers['web1'].should be_nil
+      expect(new_config.listener("http_proxy").servers["web1"]).to be_nil
     end
 
-    it 'can re-render a config file with a server added' do
-      l = @config.listener('http_proxy')
-      l.add_server('web4', '99.99.99.99', :template => l.servers['web1'])
+    it "can re-render a config file with a server added" do
+      l = @config.listener("http_proxy")
+      l.add_server("web4", "99.99.99.99", template: l.servers["web1"])
 
       new_config_text = @config.render
 
       new_config = HAProxy::Parser.new.parse(new_config_text)
-      s = new_config.listener('http_proxy').servers['web4']
-      s.should_not be_nil
-      s.name.should == 'web4'
-      s.host.should == '99.99.99.99'
-      s.port.should == '80'
-      s.attributes.to_a.should == [
-        ['weight','1'],
-        ['maxconn','512'],
-        ['check',true]
-      ]
+      s = new_config.listener("http_proxy").servers["web4"]
+      expect(s).not_to be_nil
+      expect(s.name).to eq("web4")
+      expect(s.host).to eq("99.99.99.99")
+      expect(s.port).to eq("80")
+      expect(s.attributes.to_a).to eq([
+        ["weight", "1"],
+        ["maxconn", "512"],
+        ["check", true],
+      ])
     end
   end
 end
-

data/spec/haproxy/parser_spec.rb

@@ -1,124 +1,148 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe "HAProxy::Parser" do
+require "spec_helper"
 
-  context 'multi-pool config file' do
+describe "HAProxy::Parser" do
+  context "multi-pool config file" do
     before(:each) do
       @parser = HAProxy::Parser.new
-      @config = @parser.parse_file('spec/fixtures/multi-pool.haproxy.cfg')
+      @config = @parser.parse_file("spec/fixtures/multi-pool.haproxy.cfg")
+    end
+
+    it "parses default_backend" do
+      expect(@config.frontends.size).to eq(1)
+      www_frontend = @config.frontend("www")
+      expect(www_frontend.config["default_backend"]).to eq("www_main")
+    end
+
+    it "parses defaults" do
+      expect(@config.defaults.size).to eq(1)
+
+      defaults = @config.defaults.first
+      expect(defaults.config["log"]).to eq("global")
+      expect(defaults.config["mode"]).to eq("http")
+      expect(defaults.config["retries"]).to eq("3")
+      expect(defaults.config["redispatch"]).to be_nil
+      expect(defaults.config["maxconn"]).to eq("10000")
+      expect(defaults.config["contimeout"]).to eq("5000")
+      expect(defaults.config["clitimeout"]).to eq("60000")
+      expect(defaults.config["srvtimeout"]).to eq("60000")
+      expect(defaults.config["stats"]).to eq("uri /haproxy-status")
+      expect(defaults.config["cookie"]).to eq("SERVERID insert indirect nocache")
+
+      expect(defaults.options.size).to eq(2)
+      expect(defaults.options).to include("httplog")
+      expect(defaults.options).to include("dontlognull")
     end
 
     it "parses a named backend from a config file" do
-      @config.backends.size.should == 2
-      logs_backend = @config.backend('logs')
-
-      logs_backend.servers.size.should == 4
-
-      server1 = logs_backend.servers['prd_log_1']
-      server1.name.should == 'prd_log_1'
-      server1.host.should   == '10.245.174.75'
-      server1.port.should == '8000'
-
-      server2 = logs_backend.servers['fake_logger']
-      server2.name.should == 'fake_logger'
-      server2.host.should   == '127.0.0.1'
-      server2.port.should == '9999'
-
-      server3 = logs_backend.servers['prd_log_2']
-      server3.name.should == 'prd_log_2'
-      server3.host.should   == '10.215.157.10'
-      server3.port.should == '8000'
-
-      server3 = logs_backend.servers['prd_log_3']
-      server3.name.should == 'prd_log_3'
-      server3.host.should   == 'cloudloghost1'
-      server3.port.should == '8000'
+      expect(@config.backends.size).to eq(2)
+      logs_backend = @config.backend("logs")
+
+      expect(logs_backend.servers.size).to eq(4)
+
+      server1 = logs_backend.servers["prd_log_1"]
+      expect(server1.name).to eq("prd_log_1")
+      expect(server1.host).to eq("10.245.174.75")
+      expect(server1.port).to eq("8000")
+
+      server2 = logs_backend.servers["fake_logger"]
+      expect(server2.name).to eq("fake_logger")
+      expect(server2.host).to eq("127.0.0.1")
+      expect(server2.port).to eq("9999")
+
+      server3 = logs_backend.servers["prd_log_2"]
+      expect(server3.name).to eq("prd_log_2")
+      expect(server3.host).to eq("10.215.157.10")
+      expect(server3.port).to eq("8000")
+
+      server3 = logs_backend.servers["prd_log_3"]
+      expect(server3.name).to eq("prd_log_3")
+      expect(server3.host).to eq("cloudloghost1")
+      expect(server3.port).to eq("8000")
     end
   end
 
-  context 'basic 1.5 config file' do
+  context "basic 1.5 config file" do
     before(:each) do
       @parser = HAProxy::Parser.new
-      @config = @parser.parse_file('spec/fixtures/simple.haproxy15.cfg')
+      @config = @parser.parse_file("spec/fixtures/simple.haproxy15.cfg")
     end
 
     it "parses structured configs" do
       defaults = @config.defaults.first.config
 
-      defaults['timeout connect'].should == '5000ms'
-      defaults['timeout client'].should == '5000ms'
-      defaults['timeout server'].should == '5000ms'
-
-      defaults['errorfile 400'].should == '/etc/haproxy/errors/400.http'
-      defaults['errorfile 504'].should == '/etc/haproxy/errors/504.http'
+      expect(defaults["timeout connect"]).to eq("5000ms")
+      expect(defaults["timeout client"]).to eq("5000ms")
+      expect(defaults["timeout server"]).to eq("5000ms")
 
+      expect(defaults["errorfile 400"]).to eq("/etc/haproxy/errors/400.http")
+      expect(defaults["errorfile 504"]).to eq("/etc/haproxy/errors/504.http")
     end
-
   end
 
-  context 'basic config file' do
+  context "basic config file" do
     before(:each) do
       @parser = HAProxy::Parser.new
-      @config = @parser.parse_file('spec/fixtures/simple.haproxy.cfg')
+      @config = @parser.parse_file("spec/fixtures/simple.haproxy.cfg")
     end
 
     it "parses global variables from a config file" do
-      @config.global.size.should == 3
-      @config.global['maxconn'].should == '4096'
-      @config.global['daemon'].should == nil
-      @config.global['nbproc'].should == '4'
+      expect(@config.global.size).to eq(3)
+      expect(@config.global["maxconn"]).to eq("4096")
+      expect(@config.global["daemon"]).to be_nil
+      expect(@config.global["nbproc"]).to eq("4")
     end
 
     it "parses a default set from a config file" do
-      @config.defaults.size.should == 1
+      expect(@config.defaults.size).to eq(1)
 
       defaults = @config.defaults.first
-      defaults.config['mode'].should == 'http'
-      defaults.config['clitimeout'].should == '60000'
-      defaults.config['srvtimeout'].should == '30000'
-      defaults.config['contimeout'].should == '4000'
+      expect(defaults.config["mode"]).to eq("http")
+      expect(defaults.config["clitimeout"]).to eq("60000")
+      expect(defaults.config["srvtimeout"]).to eq("30000")
+      expect(defaults.config["contimeout"]).to eq("4000")
 
-      defaults.options.size.should == 1
-      defaults.options.should include('httpclose')
+      expect(defaults.options.size).to eq(1)
+      expect(defaults.options).to include("httpclose")
     end
 
-    it 'parses a listener from a config file' do
-      @config.listeners.size.should == 1
-
-      listener = @config.listener('http_proxy')
-      listener.name.should == 'http_proxy'
-      listener.host.should == '55.55.55.55'
-      listener.port.should == '80'
-      listener.config['balance'].should == 'roundrobin'
-
-      listener.options.size.should == 2
-      listener.options.should include('httpchk')
-      listener.options.should include('forwardfor')
-
-      listener.servers.size.should == 3
-
-      server1 = listener.servers['web1']
-      server1.name.should == 'web1'
-      server1.host.should   == 'dnshost66'
-      server1.port.should == '80'
-      server1.attributes['weight'].should == '1'
-      server1.attributes['maxconn'].should == '512'
-      server1.attributes['check'].should == true
-
-      server2 = listener.servers['web2']
-      server2.name.should == 'web2'
-      server2.host.should   == '77.77.77.77'
-      server2.port.should == '80'
-      server2.attributes['weight'].should == '1'
-      server2.attributes['maxconn'].should == '512'
-      server2.attributes['check'].should == true
-
-      server3 = listener.servers['web3']
-      server3.name.should == 'web3'
-      server3.host.should   == '88.88.88.88'
-      server3.port.should == '80'
-      server3.attributes.should be_empty
+    it "parses a listener from a config file" do
+      expect(@config.listeners.size).to eq(1)
+
+      listener = @config.listener("http_proxy")
+      expect(listener.name).to eq("http_proxy")
+      expect(listener.host).to eq("55.55.55.55")
+      expect(listener.port).to eq("80")
+      expect(listener.config["balance"]).to eq("roundrobin")
+
+      expect(listener.options.size).to eq(2)
+      expect(listener.options).to include("httpchk")
+      expect(listener.options).to include("forwardfor")
+
+      expect(listener.servers.size).to eq(3)
+
+      server1 = listener.servers["web1"]
+      expect(server1.name).to eq("web1")
+      expect(server1.host).to eq("dnshost66")
+      expect(server1.port).to eq("80")
+      expect(server1.attributes["weight"]).to eq("1")
+      expect(server1.attributes["maxconn"]).to eq("512")
+      expect(server1.attributes["check"]).to eq(true)
+
+      server2 = listener.servers["web2"]
+      expect(server2.name).to eq("web2")
+      expect(server2.host).to eq("77.77.77.77")
+      expect(server2.port).to eq("80")
+      expect(server2.attributes["weight"]).to eq("1")
+      expect(server2.attributes["maxconn"]).to eq("512")
+      expect(server2.attributes["check"]).to eq(true)
+
+      server3 = listener.servers["web3"]
+      expect(server3.name).to eq("web3")
+      expect(server3.host).to eq("88.88.88.88")
+      expect(server3.port).to eq("80")
+      expect(server3.attributes).to be_empty
     end
   end
 end
-