implement generate_config

Author: aflanagan

lib/cronitor.rb

@@ -49,6 +49,17 @@ def self.validate_config
     apply_config(rollback: true)
   end
 
+  def self.generate_config(path = nil)
+    config_path = path || Cronitor.config || './cronitor.yaml'
+    yaml_content = Monitor.as_yaml
+
+    File.open(config_path, 'w') do |file|
+      file.write(yaml_content)
+    end
+
+    puts("Configuration saved to #{config_path}")
+  end
+
   def self.job(key, &block)
     monitor = Monitor.new(key)
     series = Time.now.to_f

lib/cronitor/monitor.rb

@@ -77,6 +77,35 @@ def self.put(opts = {})
       end
     end
 
+    def self.as_yaml(api_key: nil, api_version: nil)
+      timeout = Cronitor.timeout || 10
+      api_key = api_key || Cronitor.api_key
+
+      unless api_key
+        raise Error.new('No API key detected. Set Cronitor.api_key or pass api_key parameter')
+      end
+
+      headers = Cronitor::Monitor::Headers::YAML.dup
+      headers[:'Cronitor-Version'] = api_version if api_version
+
+      resp = HTTParty.get(
+        "#{MONITOR_API_URL}.yaml",
+        basic_auth: {
+          username: api_key,
+          password: ''
+        },
+        headers: headers,
+        timeout: timeout
+      )
+
+      case resp.code
+      when 200
+        resp.body
+      else
+        raise Error.new("Unexpected error #{resp.code}: #{resp.body}")
+      end
+    end
+
     def delete
       resp = HTTParty.delete(
         "#{monitor_api_url}/#{key}",

lib/cronitor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cronitor
-  VERSION = '5.2.2'
+  VERSION = '5.3.0'
 end

spec/cronitor_spec.rb

@@ -102,6 +102,57 @@
         Cronitor.validate_config()
       end
     end
+
+    context '#generate_config' do
+      let(:yaml_content) { "jobs:\n  test-job:\n    schedule: '* * * * *'\n" }
+      let(:temp_config_path) { './spec/temp_cronitor.yaml' }
+      let(:default_config_path) { './cronitor.yaml' }
+
+      after(:each) do
+        File.delete(temp_config_path) if File.exist?(temp_config_path)
+        File.delete(default_config_path) if File.exist?(default_config_path)
+        Cronitor.config = nil # Reset config to avoid test interference
+      end
+
+      context 'when no config path is set' do
+        it 'uses default path ./cronitor.yaml' do
+          Cronitor.config = nil
+          expect(Cronitor::Monitor).to receive(:as_yaml).and_return(yaml_content)
+          expect(File).to receive(:open).with('./cronitor.yaml', 'w').and_call_original
+
+          # Mock the file write to avoid creating actual file
+          allow(File).to receive(:open).with('./cronitor.yaml', 'w').and_yield(StringIO.new)
+
+          result = Cronitor.generate_config
+          expect(result).to be_nil
+        end
+      end
+
+      context 'when config path is provided' do
+        it 'uses the provided path' do
+          expect(Cronitor::Monitor).to receive(:as_yaml).and_return(yaml_content)
+
+          result = Cronitor.generate_config(temp_config_path)
+
+          expect(result).to be_nil
+          expect(File.exist?(temp_config_path)).to be(true)
+          expect(File.read(temp_config_path)).to eq(yaml_content)
+        end
+      end
+
+      context 'when Cronitor.config is set' do
+        it 'uses Cronitor.config path' do
+          Cronitor.config = temp_config_path
+          expect(Cronitor::Monitor).to receive(:as_yaml).and_return(yaml_content)
+
+          result = Cronitor.generate_config
+
+          expect(result).to be_nil
+          expect(File.exist?(temp_config_path)).to be(true)
+          expect(File.read(temp_config_path)).to eq(yaml_content)
+        end
+      end
+    end
   end
 
   describe '#job' do
@@ -243,6 +294,69 @@
       end
     end
 
+    context '#as_yaml' do
+      let(:yaml_response) { "jobs:\n  test-job:\n    schedule: '* * * * *'\n" }
+
+      it 'should fetch YAML configuration from API' do
+        expect(HTTParty).to receive(:get).with(
+          'https://cronitor.io/api/monitors.yaml',
+          hash_including(
+            basic_auth: { username: FAKE_API_KEY, password: '' },
+            headers: hash_including('Content-Type': 'application/yaml'),
+            timeout: 10
+          )
+        ).and_return(instance_double(HTTParty::Response, code: 200, body: yaml_response))
+
+        result = Cronitor::Monitor.as_yaml
+        expect(result).to eq(yaml_response)
+      end
+
+      it 'should use custom API key when provided' do
+        custom_api_key = 'custom_key'
+        expect(HTTParty).to receive(:get).with(
+          'https://cronitor.io/api/monitors.yaml',
+          hash_including(
+            basic_auth: { username: custom_api_key, password: '' }
+          )
+        ).and_return(instance_double(HTTParty::Response, code: 200, body: yaml_response))
+
+        Cronitor::Monitor.as_yaml(api_key: custom_api_key)
+      end
+
+      it 'should use custom API version when provided' do
+        api_version = '2023-01-01'
+        expect(HTTParty).to receive(:get).with(
+          'https://cronitor.io/api/monitors.yaml',
+          hash_including(
+            headers: hash_including(:'Cronitor-Version' => api_version)
+          )
+        ).and_return(instance_double(HTTParty::Response, code: 200, body: yaml_response))
+
+        Cronitor::Monitor.as_yaml(api_version: api_version)
+      end
+
+      context 'when no API key is available' do
+        it 'raises an error' do
+          original_api_key = Cronitor.api_key
+          Cronitor.api_key = nil
+
+          expect { Cronitor::Monitor.as_yaml }.to raise_error(Cronitor::Error, /No API key detected/)
+
+          Cronitor.api_key = original_api_key
+        end
+      end
+
+      context 'when API returns an error' do
+        it 'raises an error with the response details' do
+          expect(HTTParty).to receive(:get).and_return(
+            instance_double(HTTParty::Response, code: 400, body: 'Bad Request')
+          )
+
+          expect { Cronitor::Monitor.as_yaml }.to raise_error(Cronitor::Error, /Unexpected error 400: Bad Request/)
+        end
+      end
+    end
+
     context '#data' do
       it 'should fetch the monitor with cronitor api key' do
         expect(HTTParty).to receive(:get).with("https://cronitor.io/api/monitors", hash_including(basic_auth: {username: Cronitor.api_key, password: ''})).and_return(