OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/SampleBase.cs (1)

55-70: Rethrowing after logging correctly propagates failures

Adding throw; after logging ensures that any processing error for a given resultsUrl is no longer silently absorbed and instead bubbles up with its original stack trace preserved, which aligns with the PR goal of making samples fail on any error and follows .NET guidance for rethrowing exceptions.

If you want to tighten things further per .NET design and maintainability guidelines, you might consider narrowing catch (Exception e) to the specific exception types you expect from GetResourceRawAsync / ProcessRawResponseAsync (e.g., HttpRequestException, TaskCanceledException), so truly unexpected failures are not handled at this low level. This is optional and can be deferred.

OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/ERMSample.cs (1)

18-19: Using directives added for consistency across samples.

The System.CommandLine and System.CommandLine.Invocation namespaces are imported but not directly used in this file's changed code. These appear to be added for consistency with other samples. Consider removing unused imports if dotnet format or analyzers flag them.

Also applies to: 26-26, 29-29

OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/EWMSample.cs (2)

360-368: Property matching uses loose string comparison.

The check defString.Contains("filedAgainst", StringComparison.OrdinalIgnoreCase) could match unrelated properties that happen to contain "filedAgainst" as a substring. The EndsWith check is more precise, but the Contains fallback is overly permissive.

Consider using only the EndsWith check or matching against a known URI pattern:

-                        if (defString.EndsWith("filedAgainst", StringComparison.OrdinalIgnoreCase) || defString.Contains("filedAgainst", StringComparison.OrdinalIgnoreCase))
+                        if (defString.EndsWith("filedAgainst", StringComparison.OrdinalIgnoreCase))

---

411-416: Fallback logic has redundant condition.

The if (values.Length > 0) check on line 412 is always true at this point because the enclosing if on line 397 already verified values.Length > 0. This is dead code.

                             // Fallback to first if all seem unassigned or check failed
-                            if (values.Length > 0)
-                            {
-                                Logger.LogInformation("Using fallback Filed Against category: {Category}", values[0]);
-                                return new Uri(values[0]);
-                            }
+                            Logger.LogInformation("Using fallback Filed Against category: {Category}", values[0]);
+                            return new Uri(values[0]);

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/EWMSample.cs (1)

253-253: Use structured logging placeholders instead of string concatenation.

This was flagged in a previous review. Use placeholders for consistency with structured logging best practices.

-                Logger.LogError(re, "Unable to access the Jazz rootservices document at: " + webContextUrl + "/rootservices");
+                Logger.LogError(re, "Unable to access the Jazz rootservices document at: {Url}", webContextUrl + "/rootservices");

OSLC4Net_SDK/OSLC4Net.Core/Model/AllowedValuesResource.cs (1)

13-13: Consider nullable handling for About property.

Using null! suppresses compiler warnings but doesn't prevent runtime NullReferenceException if About is accessed before SetAbout is called. Consider either:

1. Making the property nullable: Uri? About { get; set; }
2. Requiring initialization via constructor

-    public Uri About { get; set; } = null!;
+    public Uri? About { get; set; }

If nullable, update GetAbout() accordingly:

-    public Uri GetAbout() => About;
+    public Uri? GetAbout() => About;

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: OSLC/oslc4net PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-11-29T19:12:48.610Z
Learning: Applies to **/Tests/**/*.cs : Prefer Verify and round-tripping checks when dealing with RDF data in tests

OSLC4Net_SDK/Examples/OSLC4Net.Client.Jazz/Oslc/Jazz/JazzFormAuthClient.cs (7)

25-25: Remove unnecessary using directive.

The Microsoft.Extensions.Logging.Abstractions namespace is not used in this file.

-using Microsoft.Extensions.Logging.Abstractions;

---

28-28: Convert to file-scoped namespace.

File-scoped namespaces reduce indentation and are a modern C# best practice.

-namespace OSLC4Net.Client.Oslc.Jazz
-{
+namespace OSLC4Net.Client.Oslc.Jazz;
+

---

38-39: Use lowercase string keyword for constants.

Consistent with .NET design guidelines, use the lowercase string keyword instead of String.

-        private const String JAZZ_AUTH_MESSAGE_HEADER = "X-com-ibm-team-repository-web-auth-msg";
-        private const String JAZZ_AUTH_FAILED = "authfailed";
+        private const string JAZZ_AUTH_MESSAGE_HEADER = "X-com-ibm-team-repository-web-auth-msg";
+        private const string JAZZ_AUTH_FAILED = "authfailed";

---

191-198: Remove redundant catch-and-rethrow blocks.

Catching specific exceptions only to immediately rethrow them serves no purpose. These blocks can be safely removed, allowing the exceptions to propagate naturally.

-            catch (JazzAuthFailedException jfe)
-            {
-                throw jfe;
-            }
-            catch (JazzAuthErrorException jee)
-            {
-                throw jee;
-            }
             catch (Exception e)
             {
                 _logger.LogError(e, "Error during login");
+                throw;
             }

---

132-132: Remove unnecessary variable initialization.

The location variable is assigned null but is unconditionally assigned before use at line 143 or 185.

-            String location = null;
+            String location;

---

215-215: Simplify null check with null-coalescing operator.

The ternary operator can be simplified using the null-coalescing operator.

-                    location = (newResp.Headers.Location != null) ? newResp.Headers.Location.AbsoluteUri : null;
+                    location = newResp.Headers.Location?.AbsoluteUri;

---

227-252: Remove unused private method.

Static analysis indicates this method is never called. Consider removing it to reduce code maintenance burden.

If this method is intended for future use, it should be made async and its exception handling should be fixed to rethrow exceptions after logging (see separate comment).

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/ETMSample.cs (3)

160-162: Uses obsolete GetRdfTypes() method.

Consider using the RdfTypes property instead to avoid deprecation warnings.

                 String testcaseCreation = await client.LookupCreationFactoryAsync(
                         serviceProviderUrl, OSLCConstants.OSLC_QM_V2,
-                        testcase.GetRdfTypes()[0].ToString()).ConfigureAwait(false);
+                        testcase.RdfTypes[0].ToString()).ConfigureAwait(false);

---

69-77: Parse errors return silently without failing the sample.

This contradicts the PR objective. When command-line arguments are invalid, the method returns without setting a non-zero exit code, causing the sample to appear successful.

         if (parseResult.Errors.Count > 0)
         {
             foreach (var error in parseResult.Errors)
             {
                 Console.Error.WriteLine(error.Message);
             }
 
-            return;
+            throw new ArgumentException("Invalid command-line arguments");
         }

---

165-170: Missing status check before accessing Location header.

Unlike EWMSample.cs (lines 206-210), this code doesn't validate that the creation succeeded before accessing the Location header. If creation fails, this could throw a NullReferenceException or produce misleading output.

                 HttpResponseMessage creationResponse = await client.CreateResourceRawAsync(
                         testcaseCreation, testcase,
                         OslcMediaType.APPLICATION_RDF_XML).ConfigureAwait(false);
-                creationResponse.ConsumeContent();
+
+                if (creationResponse.StatusCode != HttpStatusCode.Created)
+                {
+                    string errorString = await creationResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
+                    throw new InvalidOperationException($"Failed to create test case (HTTP {creationResponse.StatusCode}): {errorString}");
+                }
+
                 String testcaseLocation = creationResponse.Headers.Location.ToString();
+                creationResponse.ConsumeContent();

OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/EWMSample.cs (3)

239-243: Use structured logging placeholder instead of string concatenation.

For consistency with the rest of the codebase and structured logging best practices:

-            Logger.LogError(re, "Unable to access the Jazz rootservices document at: " + webContextUrl + "/rootservices");
+            Logger.LogError(re, "Unable to access the Jazz rootservices document at: {Url}", webContextUrl + "/rootservices");

---

195-198: Uses obsolete GetRdfTypes() method.

Consider using the RdfTypes property instead.

                 String changeRequestCreation = await client.LookupCreationFactoryAsync(
                                 serviceProviderUrl, OSLCConstants.OSLC_CM_V2,
-                                changeRequest.GetRdfTypes()[0].ToString()).ConfigureAwait(false);
+                                changeRequest.RdfTypes[0].ToString()).ConfigureAwait(false);

---

414-427: Exceptions swallowed in ResolveFiledAgainstAsync contradict PR objective.

Both the inner catch (line 414-417) and outer catch (line 423-427) log errors but don't rethrow, allowing the sample to proceed with potentially corrupted state. This contradicts the PR's goal to "ensure samples fail if there is any error."

If graceful degradation is intentional here (continuing without filedAgainst), document this explicitly. Otherwise, rethrow to fail fast:

                 catch (Exception ex)
                 {
                     Logger.LogError(ex, "Failed to deserialize AllowedValues");
+                    throw;
                 }

         catch (Exception ex)
         {
             Logger.LogError(ex, "Error resolving Filed Against allowed values");
-            return null;
+            throw;
         }

OSLC4Net_SDK/Examples/OSLC4Net.Client.Jazz/Oslc/Jazz/JazzConstants.cs (1)

16-24: LGTM! Clean refactoring to modern C# structure.

The file-scoped namespace and flattened class structure improve readability and follow current C# conventions. The constants are appropriately defined as public const string.

Optional: Consider adding XML documentation comments.

For better API discoverability, consider adding XML documentation comments to describe the purpose of each constant:

+/// <summary>
+/// Jazz namespace URIs used in OSLC integration.
+/// </summary>
 public static class JazzConstants
 {
+    /// <summary>
+    /// Jazz RTC Change Management namespace URI.
+    /// </summary>
     public const string RTC_CM = "http://jazz.net/xmlns/prod/jazz/rtc/cm/1.0/";
+    /// <summary>
+    /// Jazz Foundation Services namespace URI.
+    /// </summary>
     public const string JFS = "http://jazz.net/xmlns/prod/jazz/jfs/1.0/";
+    /// <summary>
+    /// Jazz Discovery namespace URI.
+    /// </summary>
     public const string JD = "http://jazz.net/xmlns/prod/jazz/discovery/1.0/";
+    /// <summary>
+    /// Jazz Process 0.6 namespace URI.
+    /// </summary>
     public const string JP06 = "http://jazz.net/xmlns/prod/jazz/process/0.6/";
 }

OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/Program.cs (1)

20-26: Unrecognized sample selector silently falls back to ETMSample.

When an unrecognized selector is provided (e.g., dotnet run foo), the code silently defaults to ETMSample without warning. Given the PR objective to avoid silent failures, consider logging a warning or failing explicitly for unknown selectors.

             sampleName = args[0].ToLower() switch
             {
                 "ewm" => "EWMSample",
                 "erm" => "ERMSample",
                 "etm" => "ETMSample",
-                _ => "ETMSample"
+                _ => throw new ArgumentException($"Unknown sample selector: '{args[0]}'. Valid options: ewm, erm, etm")
             };

OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/SampleBase.cs (1)

81-85: Use nullable annotation for line variable.

With nullable reference types enabled, string line = null should be string? line = null to avoid compiler warnings.

-        string line = null;
+        string? line = null;

OSLC4Net_SDK/Examples/OSLC4Net.Client.Samples/ERMSample.cs (1)

174-178: Nullable reference type annotations missing.

With NRT enabled, these declarations will produce warnings. Use string? for nullable strings:

-                String req01URL = null;
-                String req02URL = null;
-                String req03URL = null;
-                String req04URL = null;
-                String reqcoll01URL = null;
+                string? req01URL = null;
+                string? req02URL = null;
+                string? req03URL = null;
+                string? req04URL = null;
+                string? reqcoll01URL = null;

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: OSLC/oslc4net PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-11-29T19:12:48.610Z
Learning: Applies to **/Tests/**/*.cs : Prefer Verify and round-tripping checks when dealing with RDF data in tests

Learnt from: CR
Repo: OSLC/oslc4net PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-11-29T19:12:48.610Z
Learning: Applies to **/Tests/**/*.cs : Prefer Verify and round-tripping checks when dealing with RDF data in tests