Update CIMIS API and complete coverage

Author: dl-alexandre

README.md

@@ -188,8 +188,8 @@ cimis profile \
 
 - `-stations string` - CSV list or range (e.g., `2,5,10` or `1-10`)
 - `-year int` - Year to fetch
-- `-start string` - Start date `MM/DD/YYYY` (overrides year)
-- `-end string` - End date `MM/DD/YYYY` (overrides year)
+- `-start string` - Start date `YYYY-MM-DD` (overrides year; `MM/DD/YYYY` also accepted)
+- `-end string` - End date `YYYY-MM-DD` (overrides year; `MM/DD/YYYY` also accepted)
 - `-concurrency int` - Worker pool size (default: 4)
 - `-retries int` - Max retries on failure (default: 3)
 - `-perf` - Print detailed metrics
@@ -235,7 +235,7 @@ See the [library documentation](https://github.com/dl-alexandre/cimis-tsdb#readm
 
 ```bash
 # Fetch today's data for station 2
-cimis fetch-streaming -stations 2 -start $(date -v-1d +%m/%d/%Y) -end $(date +%m/%d/%Y)
+cimis fetch-streaming -stations 2 -start $(date -v-1d +%Y-%m-%d) -end $(date +%Y-%m-%d)
 
 # Query last 7 days
 cimis query -station 2 -start $(date -v-7d +%Y-%m-%d) -end $(date +%Y-%m-%d)
@@ -277,5 +277,5 @@ MIT
 ## Links
 
 - [CIMIS Website](https://cimis.water.ca.gov/)
-- [CIMIS API Documentation](https://cimis.water.ca.gov/WSNReportCriteria.aspx)
+- [CIMIS API Documentation](https://et.water.ca.gov/)
 - [cimis-tsdb Library](https://github.com/dl-alexandre/cimis-tsdb)

cmd/cimis/api_clients.go

@@ -0,0 +1,8 @@
+package main
+
+import "github.com/dl-alexandre/cimis-cli/internal/api"
+
+var (
+	newAPIClient          = api.NewClient
+	newOptimizedAPIClient = api.NewOptimizedClient
+)

cmd/cimis/browser.go

@@ -2,11 +2,18 @@ package main
 
 import (
 	"fmt"
-	"log"
 	"os/exec"
 	"runtime"
 )
 
+var (
+	lookPath            = exec.LookPath
+	startBrowserCommand = func(cmd string, args ...string) error {
+		return exec.Command(cmd, args...).Start()
+	}
+	runtimeGOOS = runtime.GOOS
+)
+
 type BrowserOpener interface {
 	Open(url string) error
 }
@@ -17,7 +24,7 @@ func (s *systemBrowserOpener) Open(url string) error {
 	var cmd string
 	var args []string
 
-	switch runtime.GOOS {
+	switch runtimeGOOS {
 	case "windows":
 		cmd = "cmd"
 		args = []string{"/c", "start", url}
@@ -29,11 +36,11 @@ func (s *systemBrowserOpener) Open(url string) error {
 		args = []string{url}
 	}
 
-	if _, err := exec.LookPath(cmd); err != nil {
+	if _, err := lookPath(cmd); err != nil {
 		return fmt.Errorf("no browser command found: %s not found. Please install a browser or manually visit: %s", cmd, url)
 	}
 
-	if err := exec.Command(cmd, args...).Start(); err != nil {
+	if err := startBrowserCommand(cmd, args...); err != nil {
 		return fmt.Errorf("failed to open browser: %w", err)
 	}
 	return nil
@@ -52,7 +59,7 @@ func cmdRegister() {
 	fmt.Printf("URL: %s\n", registerURL)
 
 	if err := openBrowser(registerURL); err != nil {
-		log.Fatalf("Failed to open browser: %v\nPlease manually visit: %s\n", err, registerURL)
+		logFatalf("Failed to open browser: %v\nPlease manually visit: %s\n", err, registerURL)
 	}
 
 	fmt.Println("Browser opened successfully!")
@@ -69,7 +76,7 @@ func cmdLogin() {
 	fmt.Printf("URL: %s\n", loginURL)
 
 	if err := openBrowser(loginURL); err != nil {
-		log.Fatalf("Failed to open browser: %v\nPlease manually visit: %s\n", err, loginURL)
+		logFatalf("Failed to open browser: %v\nPlease manually visit: %s\n", err, loginURL)
 	}
 
 	fmt.Println("Browser opened successfully!")
@@ -81,13 +88,13 @@ func cmdLogin() {
 }
 
 func cmdAPI() {
-	const apiURL = "https://cimis.water.ca.gov/WSNReportCriteria.aspx"
+	const apiURL = "https://et.water.ca.gov/"
 
 	fmt.Println("Opening CIMIS API documentation page in your browser...")
 	fmt.Printf("URL: %s\n", apiURL)
 
 	if err := openBrowser(apiURL); err != nil {
-		log.Fatalf("Failed to open browser: %v\nPlease manually visit: %s\n", err, apiURL)
+		logFatalf("Failed to open browser: %v\nPlease manually visit: %s\n", err, apiURL)
 	}
 
 	fmt.Println("Browser opened successfully!")

cmd/cimis/browser_test.go

@@ -0,0 +1,223 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"strings"
+	"testing"
+)
+
+type mockBrowserOpener struct {
+	urls []string
+	err  error
+}
+
+func (m *mockBrowserOpener) Open(url string) error {
+	m.urls = append(m.urls, url)
+	return m.err
+}
+
+func withFatalPanic(t *testing.T) {
+	t.Helper()
+
+	originalFatal := logFatal
+	originalFatalf := logFatalf
+	t.Cleanup(func() {
+		logFatal = originalFatal
+		logFatalf = originalFatalf
+	})
+
+	logFatal = func(v ...interface{}) {
+		panic("fatal")
+	}
+	logFatalf = func(format string, v ...interface{}) {
+		panic("fatalf")
+	}
+}
+
+func expectPanic(t *testing.T, fn func()) {
+	t.Helper()
+
+	defer func() {
+		if recover() == nil {
+			t.Fatal("expected panic")
+		}
+	}()
+	fn()
+}
+
+func TestBrowserCommandsUseConfiguredOpener(t *testing.T) {
+	original := browserOpener
+	defer func() { browserOpener = original }()
+
+	mock := &mockBrowserOpener{}
+	browserOpener = mock
+
+	tests := []struct {
+		name       string
+		run        func()
+		wantURL    string
+		wantOutput string
+	}{
+		{"register", cmdRegister, "https://cimis.water.ca.gov/Welcome.aspx", "After registering"},
+		{"login", cmdLogin, "https://cimis.water.ca.gov/Auth/Login.aspx", "After logging in"},
+		{"api", cmdAPI, "https://et.water.ca.gov/", "CIMIS API access"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			before := len(mock.urls)
+			output := captureStdout(t, tt.run)
+
+			if len(mock.urls) != before+1 {
+				t.Fatalf("browser opener calls = %d, want %d", len(mock.urls), before+1)
+			}
+			if got := mock.urls[len(mock.urls)-1]; got != tt.wantURL {
+				t.Fatalf("opened URL = %q, want %q", got, tt.wantURL)
+			}
+			if !strings.Contains(output, tt.wantOutput) {
+				t.Fatalf("output missing %q:\n%s", tt.wantOutput, output)
+			}
+		})
+	}
+}
+
+func TestBrowserCommandsFatalOnOpenError(t *testing.T) {
+	withFatalPanic(t)
+
+	original := browserOpener
+	defer func() { browserOpener = original }()
+
+	tests := []struct {
+		name string
+		run  func()
+	}{
+		{"register", cmdRegister},
+		{"login", cmdLogin},
+		{"api", cmdAPI},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			browserOpener = &mockBrowserOpener{err: errors.New("open failed")}
+			expectPanic(t, func() {
+				captureStdout(t, tt.run)
+			})
+		})
+	}
+}
+
+func TestFatalIfErr(t *testing.T) {
+	fatalIfErr(nil)
+
+	withFatalPanic(t)
+	expectPanic(t, func() {
+		fatalIfErr(errors.New("boom"))
+	})
+}
+
+func TestSystemBrowserOpenerOpen(t *testing.T) {
+	originalLookPath := lookPath
+	originalStart := startBrowserCommand
+	originalGOOS := runtimeGOOS
+	defer func() {
+		lookPath = originalLookPath
+		startBrowserCommand = originalStart
+		runtimeGOOS = originalGOOS
+	}()
+
+	tests := []struct {
+		goos    string
+		wantCmd string
+	}{
+		{"darwin", "open"},
+		{"windows", "cmd"},
+		{"linux", "xdg-open"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.goos, func(t *testing.T) {
+			runtimeGOOS = tt.goos
+			var gotLookPath string
+			var gotCmd string
+			var gotArgs []string
+			lookPath = func(file string) (string, error) {
+				gotLookPath = file
+				return "/usr/bin/" + file, nil
+			}
+			startBrowserCommand = func(cmd string, args ...string) error {
+				gotCmd = cmd
+				gotArgs = append([]string(nil), args...)
+				return nil
+			}
+
+			err := (&systemBrowserOpener{}).Open("https://example.test")
+			if err != nil {
+				t.Fatalf("Open() error = %v", err)
+			}
+
+			if gotLookPath != tt.wantCmd {
+				t.Fatalf("lookPath command = %q, want %q", gotLookPath, tt.wantCmd)
+			}
+			if gotCmd != tt.wantCmd {
+				t.Fatalf("start command = %q, want %q", gotCmd, tt.wantCmd)
+			}
+			if len(gotArgs) == 0 || gotArgs[len(gotArgs)-1] != "https://example.test" {
+				t.Fatalf("start args = %v, want URL as final arg", gotArgs)
+			}
+		})
+	}
+}
+
+func TestSystemBrowserOpenerOpenErrors(t *testing.T) {
+	originalLookPath := lookPath
+	originalStart := startBrowserCommand
+	defer func() {
+		lookPath = originalLookPath
+		startBrowserCommand = originalStart
+	}()
+
+	lookPath = func(file string) (string, error) {
+		return "", errors.New("missing")
+	}
+	if err := (&systemBrowserOpener{}).Open("https://example.test"); err == nil {
+		t.Fatal("expected missing browser command error")
+	}
+
+	lookPath = func(file string) (string, error) {
+		return "/usr/bin/" + file, nil
+	}
+	startBrowserCommand = func(cmd string, args ...string) error {
+		return errors.New("start failed")
+	}
+	if err := (&systemBrowserOpener{}).Open("https://example.test"); err == nil {
+		t.Fatal("expected start error")
+	}
+}
+
+func TestDefaultStartBrowserCommand(t *testing.T) {
+	if err := startBrowserCommand(os.Args[0], "-test.run=TestBrowserStartHelperProcess"); err != nil {
+		t.Fatalf("startBrowserCommand() error = %v", err)
+	}
+}
+
+func TestBrowserStartHelperProcess(t *testing.T) {}
+
+func TestRunDispatchBrowserCommands(t *testing.T) {
+	withNoAutoUpdate(t)
+
+	original := browserOpener
+	defer func() { browserOpener = original }()
+
+	mock := &mockBrowserOpener{}
+	browserOpener = mock
+
+	for _, command := range []string{"register", "login", "api-docs"} {
+		if code := run([]string{"cimis", command}); code != 0 {
+			t.Fatalf("%s exit code = %d, want 0", command, code)
+		}
+	}
+	if len(mock.urls) != 3 {
+		t.Fatalf("browser opener calls = %d, want 3", len(mock.urls))
+	}
+}

cmd/cimis/fatal.go

@@ -0,0 +1,14 @@
+package main
+
+import "log"
+
+var (
+	logFatal  = log.Fatal
+	logFatalf = log.Fatalf
+)
+
+func fatalIfErr(err error) {
+	if err != nil {
+		logFatal(err)
+	}
+}