func TestClient_ListChannels_Success(t *testing.T) {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        assert.Equal(t, "GET", r.Method)
        assert.Contains(t, r.URL.Path, "conversations.list")
        
        auth := r.Header.Get("Authorization")
        assert.True(t, strings.HasPrefix(auth, "Bearer "))
        
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"ok": true, "channels": [{"id": "C123", "name": "general"}]}`))
    }))
    defer server.Close()
    
    client := NewClientWithBaseURL(server.URL, "test-token")
    channels, err := client.ListChannels("", true, 100)
    
    require.NoError(t, err)
    assert.Len(t, channels, 1)
    assert.Equal(t, "C123", channels[0].ID)
}

func TestClient_APIError(t *testing.T) {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"ok": false, "error": "channel_not_found"}`))
    }))
    defer server.Close()
    
    client := NewClientWithBaseURL(server.URL, "test-token")
    _, err := client.GetChannelInfo("C999")
    
    require.Error(t, err)
    assert.Contains(t, err.Error(), "channel_not_found")
}

func TestClient_Pagination(t *testing.T) {
    callCount := 0
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        callCount++
        if callCount == 1 {
            w.Write([]byte(`{"ok": true, "channels": [{"id": "C1"}], "response_metadata": {"next_cursor": "abc"}}`))
        } else {
            w.Write([]byte(`{"ok": true, "channels": [{"id": "C2"}], "response_metadata": {"next_cursor": ""}}`))
        }
    }))
    defer server.Close()
    
    client := NewClientWithBaseURL(server.URL, "test-token")
    channels, err := client.ListChannels("", true, 100)
    
    require.NoError(t, err)
    assert.Len(t, channels, 2)
    assert.Equal(t, 2, callCount)
}

func TestGetAPIToken_FromEnvVar(t *testing.T) {
    t.Setenv("SLACK_API_TOKEN", "xoxb-test-token")
    
    token, err := GetAPIToken()
    require.NoError(t, err)
    assert.Equal(t, "xoxb-test-token", token)
}

func TestSetAPIToken_FilePermissions(t *testing.T) {
    if runtime.GOOS == "darwin" {
        t.Skip("File-based storage only on Linux")
    }
    
    tmpDir := t.TempDir()
    oldConfigDir := configDir
    configDir = tmpDir
    defer func() { configDir = oldConfigDir }()
    
    err := SetAPIToken("test-token")
    require.NoError(t, err)
    
    credPath := filepath.Join(tmpDir, "credentials")
    info, _ := os.Stat(credPath)
    assert.Equal(t, os.FileMode(0600), info.Mode().Perm())
}

func TestGetAPIToken_NotConfigured(t *testing.T) {
    t.Setenv("SLACK_API_TOKEN", "")
    // ... setup to ensure no stored token
    
    _, err := GetAPIToken()
    require.Error(t, err)
    assert.Contains(t, err.Error(), "no API token found")
}

func TestChannelsList_Success(t *testing.T) {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(`{"ok": true, "channels": [{"id": "C123", "name": "general", "num_members": 10}]}`))
    }))
    defer server.Close()
    
    var stdout, stderr bytes.Buffer
    cmd := NewCmdChannelsList()
    cmd.SetOut(&stdout)
    cmd.SetErr(&stderr)
    
    // Inject test client
    testClient := client.NewClientWithBaseURL(server.URL, "test-token")
    runListWithClient = func(opts *listOptions) error {
        return runList(opts, testClient)
    }
    
    err := cmd.Execute()
    require.NoError(t, err)
    assert.Contains(t, stdout.String(), "general")
}

func TestChannelsList_JSONOutput(t *testing.T) {
    // ... setup server ...
    
    cmd := NewCmdChannelsList()
    cmd.SetArgs([]string{"--json"})
    
    err := cmd.Execute()
    require.NoError(t, err)
    
    var result []client.Channel
    err = json.Unmarshal(stdout.Bytes(), &result)
    require.NoError(t, err)
    assert.Len(t, result, 1)
}